[llvm-commits] CVS: llvm/lib/CodeGen/AsmPrinter.cpp

[Chris Lattner]

Changes in directory llvm/lib/CodeGen:

AsmPrinter.cpp updated: 1.87 -> 1.88
---
Log message:

Instead of blindly looking past constantexpr casts, actually constant
fold them.  This correctly truncates constants that are too large for the
destination slot and makes the code easier to understand.  This fixes PR853: http://llvm.org/PR853 
and Regression/CodeGen/X86/2006-07-28-AsmPrint-Long-As-Pointer.ll


---
Diffs of the changes:  (+20 -14)

 AsmPrinter.cpp |   34 ++++++++++++++++++++--------------
 1 files changed, 20 insertions(+), 14 deletions(-)


Index: llvm/lib/CodeGen/AsmPrinter.cpp
diff -u llvm/lib/CodeGen/AsmPrinter.cpp:1.87 llvm/lib/CodeGen/AsmPrinter.cpp:1.88
--- llvm/lib/CodeGen/AsmPrinter.cpp:1.87	Thu Jul 27 19:17:20 2006
+++ llvm/lib/CodeGen/AsmPrinter.cpp	Fri Jul 28 20:57:19 2006
@@ -385,23 +385,29 @@
       break;
     }
     case Instruction::Cast: {
-      // Support only non-converting or widening casts for now, that is, ones
-      // that do not involve a change in value.  This assertion is really gross,
-      // and may not even be a complete check.
+      // Support only foldable casts to/from pointers that can be eliminated by
+      // changing the pointer to the appropriately sized integer type.
       Constant *Op = CE->getOperand(0);
       const Type *OpTy = Op->getType(), *Ty = CE->getType();
 
-      // Remember, kids, pointers can be losslessly converted back and forth
-      // into 32-bit or wider integers, regardless of signedness. :-P
-      assert(((isa<PointerType>(OpTy)
-               && (Ty == Type::LongTy || Ty == Type::ULongTy
-                   || Ty == Type::IntTy || Ty == Type::UIntTy))
-              || (isa<PointerType>(Ty)
-                  && (OpTy == Type::LongTy || OpTy == Type::ULongTy
-                      || OpTy == Type::IntTy || OpTy == Type::UIntTy))
-              || (((TD->getTypeSize(Ty) >= TD->getTypeSize(OpTy))
-                   && OpTy->isLosslesslyConvertibleTo(Ty))))
-             && "FIXME: Don't yet support this kind of constant cast expr");
+      // Handle casts to pointers by changing them into casts to the appropriate
+      // integer type.  This promotes constant folding and simplifies this code.
+      if (isa<PointerType>(Ty)) {
+        const Type *IntPtrTy = TD->getIntPtrType();
+        Op = ConstantExpr::getCast(Op, IntPtrTy);
+        return EmitConstantValueOnly(Op);
+      }
+      
+      // We know the dest type is not a pointer.  Is the src value a pointer or
+      // integral?
+      if (isa<PointerType>(OpTy) || OpTy->isIntegral()) {
+        // We can emit the pointer value into this slot if the slot is an
+        // integer slot greater or equal to the size of the pointer.
+        if (Ty->isIntegral() && TD->getTypeSize(Ty) >= TD->getTypeSize(OpTy))
+          return EmitConstantValueOnly(Op);
+      }
+      
+      assert(0 && "FIXME: Don't yet support this kind of constant cast expr");
       EmitConstantValueOnly(Op);
       break;
     }