[llvm-commits] [llvm] r61850 - /llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp

Chris Lattner sabre at nondot.org
Tue Jan 6 22:34:28 PST 2009


Author: lattner
Date: Wed Jan  7 00:34:28 2009
New Revision: 61850

URL: http://llvm.org/viewvc/llvm-project?rev=61850&view=rev
Log:
Get TargetData once up front and cache as an ivar instead of
requerying it all over the place.

Modified:
    llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp

Modified: llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp
URL: http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp?rev=61850&r1=61849&r2=61850&view=diff

==============================================================================
--- llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp (original)
+++ llvm/trunk/lib/Transforms/Scalar/ScalarReplAggregates.cpp Wed Jan  7 00:34:28 2009
@@ -70,6 +70,8 @@
     }
 
   private:
+    TargetData *TD;
+    
     /// AllocaInfo - When analyzing uses of an alloca instruction, this captures
     /// information about the uses.  All these fields are initialized to false
     /// and set to true when something is learned.
@@ -136,6 +138,8 @@
 
 
 bool SROA::runOnFunction(Function &F) {
+  TD = &getAnalysis<TargetData>();
+  
   bool Changed = performPromotion(F);
   while (1) {
     bool LocalChange = performScalarRepl(F);
@@ -199,8 +203,6 @@
     if (AllocationInst *A = dyn_cast<AllocationInst>(I))
       WorkList.push_back(A);
 
-  const TargetData &TD = getAnalysis<TargetData>();
-  
   // Process the worklist
   bool Changed = false;
   while (!WorkList.empty()) {
@@ -233,7 +235,7 @@
          isa<ArrayType>(AI->getAllocatedType())) &&
         AI->getAllocatedType()->isSized() &&
         // Do not promote any struct whose size is larger than "128" bytes.
-        TD.getABITypeSize(AI->getAllocatedType()) < SRThreshold &&
+        TD->getABITypeSize(AI->getAllocatedType()) < SRThreshold &&
         // Do not promote any struct into more than "32" separate vars.
         getNumSAElements(AI->getAllocatedType()) < SRThreshold/4) {
       // Check that all of the users of the allocation are capable of being
@@ -551,9 +553,8 @@
   if (!Length) return MarkUnsafe(Info);
   
   // If not the whole aggregate, give up.
-  const TargetData &TD = getAnalysis<TargetData>();
   if (Length->getZExtValue() !=
-      TD.getABITypeSize(AI->getType()->getElementType()))
+      TD->getABITypeSize(AI->getType()->getElementType()))
     return MarkUnsafe(Info);
   
   // We only know about memcpy/memset/memmove.
@@ -593,7 +594,6 @@
 void SROA::RewriteBitCastUserOfAlloca(Instruction *BCInst, AllocationInst *AI,
                                       SmallVector<AllocaInst*, 32> &NewElts) {
   Constant *Zero = Constant::getNullValue(Type::Int32Ty);
-  const TargetData &TD = getAnalysis<TargetData>();
   
   Value::use_iterator UI = BCInst->use_begin(), UE = BCInst->use_end();
   while (UI != UE) {
@@ -697,7 +697,7 @@
                 ValTy = VTy->getElementType();
 
               // Construct an integer with the right value.
-              unsigned EltSize = TD.getTypeSizeInBits(ValTy);
+              unsigned EltSize = TD->getTypeSizeInBits(ValTy);
               APInt OneVal(EltSize, CI->getZExtValue());
               APInt TotalVal(OneVal);
               // Set each byte.
@@ -738,7 +738,7 @@
         OtherElt = new BitCastInst(OtherElt, BytePtrTy,OtherElt->getNameStr(),
                                    MI);
     
-      unsigned EltSize = TD.getABITypeSize(EltTy);
+      unsigned EltSize = TD->getABITypeSize(EltTy);
 
       // Finally, insert the meminst for this element.
       if (isa<MemCpyInst>(MI) || isa<MemMoveInst>(MI)) {
@@ -832,7 +832,7 @@
   // types, but may actually be used.  In these cases, we refuse to promote the
   // struct.
   if (Info.isMemCpySrc && Info.isMemCpyDst &&
-      HasPadding(AI->getType()->getElementType(), getAnalysis<TargetData>()))
+      HasPadding(AI->getType()->getElementType(), *TD))
     return 0;
 
   // If we require cleanup, return 1, otherwise return 3.
@@ -967,10 +967,9 @@
   return false;
 }
 
-/// getUIntAtLeastAsBigAs - Return an unsigned integer type that is at least
-/// as big as the specified type.  If there is no suitable type, this returns
-/// null.
-const Type *getUIntAtLeastAsBigAs(unsigned NumBits) {
+/// getIntAtLeastAsBigAs - Return an integer type that is at least as big as the
+/// specified type.  If there is no suitable type, this returns null.
+const Type *getIntAtLeastAsBigAs(unsigned NumBits) {
   if (NumBits > 64) return 0;
   if (NumBits > 32) return Type::Int64Ty;
   if (NumBits > 16) return Type::Int32Ty;
@@ -986,7 +985,6 @@
 ///
 const Type *SROA::CanConvertToScalar(Value *V, bool &IsNotTrivial) {
   const Type *UsedType = Type::VoidTy; // No uses, no forced type.
-  const TargetData &TD = getAnalysis<TargetData>();
   const PointerType *PTy = cast<PointerType>(V->getType());
 
   for (Value::use_iterator UI = V->use_begin(), E = V->use_end(); UI!=E; ++UI) {
@@ -998,7 +996,7 @@
       if (!LI->getType()->isSingleValueType())
         return 0;
 
-      if (MergeInType(LI->getType(), UsedType, TD))
+      if (MergeInType(LI->getType(), UsedType, *TD))
         return 0;
       
     } else if (StoreInst *SI = dyn_cast<StoreInst>(User)) {
@@ -1012,17 +1010,17 @@
       
       // NOTE: We could handle storing of FP imms into integers here!
       
-      if (MergeInType(SI->getOperand(0)->getType(), UsedType, TD))
+      if (MergeInType(SI->getOperand(0)->getType(), UsedType, *TD))
         return 0;
     } else if (BitCastInst *CI = dyn_cast<BitCastInst>(User)) {
       IsNotTrivial = true;
       const Type *SubTy = CanConvertToScalar(CI, IsNotTrivial);
-      if (!SubTy || MergeInType(SubTy, UsedType, TD)) return 0;
+      if (!SubTy || MergeInType(SubTy, UsedType, *TD)) return 0;
     } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) {
       // Check to see if this is stepping over an element: GEP Ptr, int C
       if (GEP->getNumOperands() == 2 && isa<ConstantInt>(GEP->getOperand(1))) {
         unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getZExtValue();
-        unsigned ElSize = TD.getABITypeSize(PTy->getElementType());
+        unsigned ElSize = TD->getABITypeSize(PTy->getElementType());
         unsigned BitOffset = Idx*ElSize*8;
         if (BitOffset > 64 || !isPowerOf2_32(ElSize)) return 0;
         
@@ -1031,8 +1029,8 @@
         if (SubElt == 0) return 0;
         if (SubElt != Type::VoidTy && SubElt->isInteger()) {
           const Type *NewTy = 
-            getUIntAtLeastAsBigAs(TD.getABITypeSizeInBits(SubElt)+BitOffset);
-          if (NewTy == 0 || MergeInType(NewTy, UsedType, TD)) return 0;
+            getIntAtLeastAsBigAs(TD->getABITypeSizeInBits(SubElt)+BitOffset);
+          if (NewTy == 0 || MergeInType(NewTy, UsedType, *TD)) return 0;
           continue;
         }
       } else if (GEP->getNumOperands() == 3 && 
@@ -1051,12 +1049,12 @@
           if (Idx >= VectorTy->getNumElements()) return 0;  // Out of range.
 
           // Merge in the vector type.
-          if (MergeInType(VectorTy, UsedType, TD)) return 0;
+          if (MergeInType(VectorTy, UsedType, *TD)) return 0;
           
           const Type *SubTy = CanConvertToScalar(GEP, IsNotTrivial);
           if (SubTy == 0) return 0;
           
-          if (SubTy != Type::VoidTy && MergeInType(SubTy, UsedType, TD))
+          if (SubTy != Type::VoidTy && MergeInType(SubTy, UsedType, *TD))
             return 0;
 
           // We'll need to change this to an insert/extract element operation.
@@ -1068,11 +1066,11 @@
         } else {
           return 0;
         }
-        const Type *NTy = getUIntAtLeastAsBigAs(TD.getABITypeSizeInBits(AggTy));
-        if (NTy == 0 || MergeInType(NTy, UsedType, TD)) return 0;
+        const Type *NTy = getIntAtLeastAsBigAs(TD->getABITypeSizeInBits(AggTy));
+        if (NTy == 0 || MergeInType(NTy, UsedType, *TD)) return 0;
         const Type *SubTy = CanConvertToScalar(GEP, IsNotTrivial);
         if (SubTy == 0) return 0;
-        if (SubTy != Type::VoidTy && MergeInType(SubTy, UsedType, TD))
+        if (SubTy != Type::VoidTy && MergeInType(SubTy, UsedType, *TD))
           return 0;
         continue;    // Everything looks ok
       }
@@ -1135,9 +1133,8 @@
     } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) {
       const PointerType *AggPtrTy = 
         cast<PointerType>(GEP->getOperand(0)->getType());
-      const TargetData &TD = getAnalysis<TargetData>();
       unsigned AggSizeInBits =
-        TD.getABITypeSizeInBits(AggPtrTy->getElementType());
+        TD->getABITypeSizeInBits(AggPtrTy->getElementType());
 
       // Check to see if this is stepping over an element: GEP Ptr, int C
       unsigned NewOffset = Offset;
@@ -1152,12 +1149,12 @@
         const Type *AggTy = AggPtrTy->getElementType();
         if (const SequentialType *SeqTy = dyn_cast<SequentialType>(AggTy)) {
           unsigned ElSizeBits =
-            TD.getABITypeSizeInBits(SeqTy->getElementType());
+            TD->getABITypeSizeInBits(SeqTy->getElementType());
 
           NewOffset += ElSizeBits*Idx;
         } else if (const StructType *STy = dyn_cast<StructType>(AggTy)) {
           unsigned EltBitOffset =
-            TD.getStructLayout(STy)->getElementOffsetInBits(Idx);
+            TD->getStructLayout(STy)->getElementOffsetInBits(Idx);
           
           NewOffset += EltBitOffset;
         } else {
@@ -1209,10 +1206,9 @@
       return new BitCastInst(NV, LI->getType(), LI->getName(), LI);
 
     // Otherwise it must be an element access.
-    const TargetData &TD = getAnalysis<TargetData>();
     unsigned Elt = 0;
     if (Offset) {
-      unsigned EltSize = TD.getABITypeSizeInBits(VTy->getElementType());
+      unsigned EltSize = TD->getABITypeSizeInBits(VTy->getElementType());
       Elt = Offset/EltSize;
       Offset -= EltSize*Elt;
     }
@@ -1229,13 +1225,12 @@
   // If this is a big-endian system and the load is narrower than the
   // full alloca type, we need to do a shift to get the right bits.
   int ShAmt = 0;
-  const TargetData &TD = getAnalysis<TargetData>();
-  if (TD.isBigEndian()) {
+  if (TD->isBigEndian()) {
     // On big-endian machines, the lowest bit is stored at the bit offset
     // from the pointer given by getTypeStoreSizeInBits.  This matters for
     // integers with a bitwidth that is not a multiple of 8.
-    ShAmt = TD.getTypeStoreSizeInBits(NTy) -
-    TD.getTypeStoreSizeInBits(LI->getType()) - Offset;
+    ShAmt = TD->getTypeStoreSizeInBits(NTy) -
+            TD->getTypeStoreSizeInBits(LI->getType()) - Offset;
   } else {
     ShAmt = Offset;
   }
@@ -1253,7 +1248,7 @@
                                    LI->getName(), LI);
   
   // Finally, unconditionally truncate the integer to the right width.
-  unsigned LIBitWidth = TD.getTypeSizeInBits(LI->getType());
+  unsigned LIBitWidth = TD->getTypeSizeInBits(LI->getType());
   if (LIBitWidth < NTy->getBitWidth())
     NV = new TruncInst(NV, IntegerType::get(LIBitWidth),
                        LI->getName(), LI);
@@ -1299,8 +1294,7 @@
       SV = new BitCastInst(SV, AllocaType, SV->getName(), SI);
     } else {
       // Must be an element insertion.
-      const TargetData &TD = getAnalysis<TargetData>();
-      unsigned Elt = Offset/TD.getABITypeSizeInBits(PTy->getElementType());
+      unsigned Elt = Offset/TD->getABITypeSizeInBits(PTy->getElementType());
       SV = InsertElementInst::Create(Old, SV,
                                      ConstantInt::get(Type::Int32Ty, Elt),
                                      "tmp", SI);
@@ -1316,16 +1310,15 @@
     // If SV is a float, convert it to the appropriate integer type.
     // If it is a pointer, do the same, and also handle ptr->ptr casts
     // here.
-    const TargetData &TD = getAnalysis<TargetData>();
-    unsigned SrcWidth = TD.getTypeSizeInBits(SV->getType());
-    unsigned DestWidth = TD.getTypeSizeInBits(AllocaType);
-    unsigned SrcStoreWidth = TD.getTypeStoreSizeInBits(SV->getType());
-    unsigned DestStoreWidth = TD.getTypeStoreSizeInBits(AllocaType);
+    unsigned SrcWidth = TD->getTypeSizeInBits(SV->getType());
+    unsigned DestWidth = TD->getTypeSizeInBits(AllocaType);
+    unsigned SrcStoreWidth = TD->getTypeStoreSizeInBits(SV->getType());
+    unsigned DestStoreWidth = TD->getTypeStoreSizeInBits(AllocaType);
     if (SV->getType()->isFloatingPoint())
       SV = new BitCastInst(SV, IntegerType::get(SrcWidth),
                            SV->getName(), SI);
     else if (isa<PointerType>(SV->getType()))
-      SV = new PtrToIntInst(SV, TD.getIntPtrType(), SV->getName(), SI);
+      SV = new PtrToIntInst(SV, TD->getIntPtrType(), SV->getName(), SI);
     
     // Always zero extend the value if needed.
     if (SV->getType() != AllocaType)
@@ -1334,7 +1327,7 @@
     // If this is a big-endian system and the store is narrower than the
     // full alloca type, we need to do a shift to get the right bits.
     int ShAmt = 0;
-    if (TD.isBigEndian()) {
+    if (TD->isBigEndian()) {
       // On big-endian machines, the lowest bit is stored at the bit offset
       // from the pointer given by getTypeStoreSizeInBits.  This matters for
       // integers with a bitwidth that is not a multiple of 8.





More information about the llvm-commits mailing list