[llvm-commits] CVS: llvm-poolalloc/lib/PoolAllocate/AccessTrace.cpp PointerCompress.cpp PoolAllocate.cpp PoolOptimize.cpp TransformFunctionBody.cpp

John Criswell criswell at cs.uiuc.edu
Wed Dec 13 12:07:02 PST 2006



Changes in directory llvm-poolalloc/lib/PoolAllocate:

AccessTrace.cpp updated: 1.6 -> 1.7
PointerCompress.cpp updated: 1.72 -> 1.73
PoolAllocate.cpp updated: 1.127 -> 1.128
PoolOptimize.cpp updated: 1.8 -> 1.9
TransformFunctionBody.cpp updated: 1.57 -> 1.58
---
Log message:

Updated to LLVM Mainline API.  This required changing statistics to be
non-templated and switching over to using the new cast instructions.


---
Diffs of the changes:  (+65 -50)

 AccessTrace.cpp           |    4 ++--
 PointerCompress.cpp       |   41 +++++++++++++++++++++--------------------
 PoolAllocate.cpp          |   29 ++++++++++++++++++++---------
 PoolOptimize.cpp          |    2 +-
 TransformFunctionBody.cpp |   39 +++++++++++++++++++++------------------
 5 files changed, 65 insertions(+), 50 deletions(-)


Index: llvm-poolalloc/lib/PoolAllocate/AccessTrace.cpp
diff -u llvm-poolalloc/lib/PoolAllocate/AccessTrace.cpp:1.6 llvm-poolalloc/lib/PoolAllocate/AccessTrace.cpp:1.7
--- llvm-poolalloc/lib/PoolAllocate/AccessTrace.cpp:1.6	Tue Oct 24 16:43:50 2006
+++ llvm-poolalloc/lib/PoolAllocate/AccessTrace.cpp	Wed Dec 13 14:06:42 2006
@@ -81,10 +81,10 @@
   if (Node == 0) return;
 
   Value *PD = FI->PoolDescriptors[Node];
-  Ptr = new CastInst(Ptr, VoidPtrTy, Ptr->getName(), I);
+  Ptr = CastInst::createPointerCast (Ptr, VoidPtrTy, Ptr->getName(), I);
 
   if (PD)
-    PD = new CastInst(PD, VoidPtrTy, PD->getName(), I);
+    PD = CastInst::createPointerCast (PD, VoidPtrTy, PD->getName(), I);
   else
     PD = Constant::getNullValue(VoidPtrTy);
 


Index: llvm-poolalloc/lib/PoolAllocate/PointerCompress.cpp
diff -u llvm-poolalloc/lib/PoolAllocate/PointerCompress.cpp:1.72 llvm-poolalloc/lib/PoolAllocate/PointerCompress.cpp:1.73
--- llvm-poolalloc/lib/PoolAllocate/PointerCompress.cpp:1.72	Fri Nov  3 14:14:34 2006
+++ llvm-poolalloc/lib/PoolAllocate/PointerCompress.cpp	Wed Dec 13 14:06:42 2006
@@ -54,11 +54,11 @@
          cl::desc("Enable Andrew's fixes/hacks"));
   
 
-  Statistic<> NumCompressed("pointercompress",
+  Statistic NumCompressed("pointercompress",
                             "Number of pools pointer compressed");
-  Statistic<> NumNotCompressed("pointercompress",
+  Statistic NumNotCompressed("pointercompress",
                                "Number of pools not compressible");
-  Statistic<> NumCloned    ("pointercompress", "Number of functions cloned");
+  Statistic NumCloned    ("pointercompress", "Number of functions cloned");
 
   class CompressedPoolInfo;
 
@@ -703,7 +703,7 @@
         // Add Idx*sizeof(NewElementType) to the index.
         const Type *ElTy = cast<SequentialType>(NTy)->getElementType();
         if (Idx->getType() != SCALARUINTTYPE)
-          Idx = new CastInst(Idx, SCALARUINTTYPE, Idx->getName(), &GEPI);
+          Idx = CastInst::createSExtOrBitCast(Idx, SCALARUINTTYPE, Idx->getName(), &GEPI);
 
         Constant *Scale = ConstantInt::get(SCALARUINTTYPE,
                                             TD.getTypeSize(ElTy));
@@ -729,7 +729,7 @@
     // type.
     if (getPoolInfo(&LI)) {
       Value *NLI = new LoadInst(LI.getOperand(0), LI.getName()+".cp", &LI);
-      Value *NC = new CastInst(NLI, SCALARUINTTYPE, NLI->getName(), &LI);
+      Value *NC = CastInst::createZExtOrBitCast(NLI, SCALARUINTTYPE, NLI->getName(), &LI);
       setTransformedValue(LI, NC);
     }
     return;
@@ -746,19 +746,19 @@
   std::vector<Value*> Ops;
   Ops.push_back(getTransformedValue(LI.getOperand(0)));
   if (Ops[0]->getType() == Type::UShortTy)
-    Ops[0] = new CastInst(Ops[0], Type::UIntTy, "extend_idx", &LI);
+    Ops[0] = CastInst::createZExtOrBitCast(Ops[0], Type::UIntTy, "extend_idx", &LI);
   Value *SrcPtr = new GetElementPtrInst(BasePtr, Ops,
                                         LI.getOperand(0)->getName()+".pp", &LI);
   const Type *DestTy = LoadingCompressedPtr ? MEMUINTTYPE : LI.getType();
-  SrcPtr = new CastInst(SrcPtr, PointerType::get(DestTy),
-                        SrcPtr->getName(), &LI);
+  SrcPtr = CastInst::createPointerCast(SrcPtr, PointerType::get(DestTy),
+                                      SrcPtr->getName(), &LI);
   std::string OldName = LI.getName(); LI.setName("");
   Value *NewLoad = new LoadInst(SrcPtr, OldName, &LI);
 
   if (LoadingCompressedPtr) {
     // Convert from MEMUINTTYPE to SCALARUINTTYPE if different.
     if (MEMUINTTYPE != SCALARUINTTYPE)
-      NewLoad = new CastInst(NewLoad, SCALARUINTTYPE, NewLoad->getName(), &LI);
+      NewLoad = CastInst::createZExtOrBitCast(NewLoad, SCALARUINTTYPE, NewLoad->getName(), &LI);
 
     setTransformedValue(LI, NewLoad);
   } else {
@@ -777,8 +777,8 @@
     // cast the index to a pointer type and store that.
     if (getPoolInfo(SI.getOperand(0))) {
       Value *SrcVal = getTransformedValue(SI.getOperand(0));
-      SrcVal = new CastInst(SrcVal, SI.getOperand(0)->getType(),
-                            SrcVal->getName(), &SI);
+      SrcVal = CastInst::createPointerCast(SrcVal, SI.getOperand(0)->getType(),
+                                           SrcVal->getName(), &SI);
       SI.setOperand(0, SrcVal);
     }
     return;
@@ -798,7 +798,7 @@
 
       // If SCALAR type is not the MEM type, reduce it now.
       if (SrcVal->getType() != MEMUINTTYPE)
-        SrcVal = new CastInst(SrcVal, MEMUINTTYPE, SrcVal->getName(), &SI);
+        SrcVal = CastInst::createZExtOrBitCast(SrcVal, MEMUINTTYPE, SrcVal->getName(), &SI);
     }
   } else {
     // FIXME: This assumes that all null pointers are compressed!
@@ -812,13 +812,14 @@
   std::vector<Value*> Ops;
   Ops.push_back(getTransformedValue(SI.getOperand(1)));
   if (Ops[0]->getType() == Type::UShortTy)
-    Ops[0] = new CastInst(Ops[0], Type::UIntTy, "extend_idx", &SI);
+    Ops[0] = CastInst::createZExtOrBitCast(Ops[0], Type::UIntTy, "extend_idx", &SI);
 
   Value *DestPtr = new GetElementPtrInst(BasePtr, Ops,
                                          SI.getOperand(1)->getName()+".pp",
                                          &SI);
-  DestPtr = new CastInst(DestPtr, PointerType::get(SrcVal->getType()),
-                         DestPtr->getName(), &SI);
+  DestPtr = CastInst::createPointerCast(DestPtr,
+                                        PointerType::get(SrcVal->getType()),
+                                        DestPtr->getName(), &SI);
   new StoreInst(SrcVal, DestPtr, &SI);
 
   // Finally, explicitly remove the store from the program, as it does not
@@ -951,7 +952,7 @@
         Value *BasePtr = DestPI->EmitPoolBaseLoad(CI);
         Value *SrcPtr = new GetElementPtrInst(BasePtr, Ops,
                                        CI.getOperand(2)->getName()+".pp", &CI);
-        SrcPtr = new CastInst(SrcPtr, CI.getOperand(2)->getType(), "", &CI);
+        SrcPtr = CastInst::createPointerCast(SrcPtr, CI.getOperand(2)->getType(), "", &CI);
         CI.setOperand(2, SrcPtr);
         return;
       }
@@ -962,7 +963,7 @@
         Value *BasePtr = DestPI->EmitPoolBaseLoad(CI);
         Value *SrcPtr = new GetElementPtrInst(BasePtr, Ops,
                                        CI.getOperand(1)->getName()+".pp", &CI);
-        SrcPtr = new CastInst(SrcPtr, CI.getOperand(1)->getType(), "", &CI);
+        SrcPtr = CastInst::createPointerCast(SrcPtr, CI.getOperand(1)->getType(), "", &CI);
         CI.setOperand(1, SrcPtr);
         return;
       }
@@ -975,7 +976,7 @@
         Value *BasePtr = DestPI->EmitPoolBaseLoad(CI);
         Value *SrcPtr = new GetElementPtrInst(BasePtr, Ops,
                                        CI.getOperand(1)->getName()+".pp", &CI);
-        SrcPtr = new CastInst(SrcPtr, CI.getOperand(1)->getType(), "", &CI);
+        SrcPtr = CastInst::createPointerCast(SrcPtr, CI.getOperand(1)->getType(), "", &CI);
         CI.setOperand(1, SrcPtr);
         return;
       }
@@ -989,7 +990,7 @@
         Value *BasePtr = DestPI->EmitPoolBaseLoad(CI);
         Value *SrcPtr = new GetElementPtrInst(BasePtr, Ops,
                                        CI.getOperand(1)->getName()+".pp", &CI);
-        SrcPtr = new CastInst(SrcPtr, CI.getOperand(1)->getType(), "", &CI);
+        SrcPtr = CastInst::createPointerCast(SrcPtr, CI.getOperand(1)->getType(), "", &CI);
         CI.setOperand(1, SrcPtr);
         doret = true;
       }
@@ -999,7 +1000,7 @@
         Value *BasePtr = DestPI->EmitPoolBaseLoad(CI);
         Value *SrcPtr = new GetElementPtrInst(BasePtr, Ops,
                                        CI.getOperand(2)->getName()+".pp", &CI);
-        SrcPtr = new CastInst(SrcPtr, CI.getOperand(2)->getType(), "", &CI);
+        SrcPtr = CastInst::createPointerCast(SrcPtr, CI.getOperand(2)->getType(), "", &CI);
         CI.setOperand(2, SrcPtr);
         doret = true;
       }


Index: llvm-poolalloc/lib/PoolAllocate/PoolAllocate.cpp
diff -u llvm-poolalloc/lib/PoolAllocate/PoolAllocate.cpp:1.127 llvm-poolalloc/lib/PoolAllocate/PoolAllocate.cpp:1.128
--- llvm-poolalloc/lib/PoolAllocate/PoolAllocate.cpp:1.127	Fri Nov  3 14:14:34 2006
+++ llvm-poolalloc/lib/PoolAllocate/PoolAllocate.cpp	Wed Dec 13 14:06:42 2006
@@ -57,14 +57,14 @@
   RegisterPass<PoolAllocatePassAllPools>
   Y("poolalloc-passing-all-pools", "Pool allocate disjoint data structures");
 
-  Statistic<> NumArgsAdded("poolalloc", "Number of function arguments added");
-  Statistic<> MaxArgsAdded("poolalloc", "Maximum function arguments added to one function");
-  Statistic<> NumCloned   ("poolalloc", "Number of functions cloned");
-  Statistic<> NumPools    ("poolalloc", "Number of pools allocated");
-  Statistic<> NumTSPools  ("poolalloc", "Number of typesafe pools");
-  Statistic<> NumPoolFree ("poolalloc", "Number of poolfree's elided");
-  Statistic<> NumNonprofit("poolalloc", "Number of DSNodes not profitable");
-  Statistic<> NumColocated("poolalloc", "Number of DSNodes colocated");
+  Statistic NumArgsAdded("poolalloc", "Number of function arguments added");
+  Statistic MaxArgsAdded("poolalloc", "Maximum function arguments added to one function");
+  Statistic NumCloned   ("poolalloc", "Number of functions cloned");
+  Statistic NumPools    ("poolalloc", "Number of pools allocated");
+  Statistic NumTSPools  ("poolalloc", "Number of typesafe pools");
+  Statistic NumPoolFree ("poolalloc", "Number of poolfree's elided");
+  Statistic NumNonprofit("poolalloc", "Number of DSNodes not profitable");
+  Statistic NumColocated("poolalloc", "Number of DSNodes colocated");
 
   const Type *VoidPtrTy;
 
@@ -244,7 +244,18 @@
         bool CondIsTrue = User->getOpcode() == Instruction::SetNE;
         User->replaceAllUsesWith(ConstantBool::get(CondIsTrue));
       }
-    } else if (User->getOpcode() == Instruction::Cast) {
+    } else if ((User->getOpcode() == Instruction::Trunc) ||
+               (User->getOpcode() == Instruction::ZExt) ||
+               (User->getOpcode() == Instruction::SExt) ||
+               (User->getOpcode() == Instruction::FPToUI) ||
+               (User->getOpcode() == Instruction::FPToSI) ||
+               (User->getOpcode() == Instruction::UIToFP) ||
+               (User->getOpcode() == Instruction::SIToFP) ||
+               (User->getOpcode() == Instruction::FPTrunc) ||
+               (User->getOpcode() == Instruction::FPExt) ||
+               (User->getOpcode() == Instruction::PtrToInt) ||
+               (User->getOpcode() == Instruction::IntToPtr) ||
+               (User->getOpcode() == Instruction::BitCast)) {
       // Casted pointers are also not null.
       if (isa<PointerType>(User->getType()))
         OptimizePointerNotNull(User);


Index: llvm-poolalloc/lib/PoolAllocate/PoolOptimize.cpp
diff -u llvm-poolalloc/lib/PoolAllocate/PoolOptimize.cpp:1.8 llvm-poolalloc/lib/PoolAllocate/PoolOptimize.cpp:1.9
--- llvm-poolalloc/lib/PoolAllocate/PoolOptimize.cpp:1.8	Fri Nov  3 15:07:06 2006
+++ llvm-poolalloc/lib/PoolAllocate/PoolOptimize.cpp	Wed Dec 13 14:06:42 2006
@@ -20,7 +20,7 @@
 using namespace llvm;
 
 namespace {
-  Statistic<> NumBumpPtr("poolalloc", "Number of bump pointer pools");
+  Statistic NumBumpPtr("poolalloc", "Number of bump pointer pools");
 
   struct PoolOptimize : public ModulePass {
     bool runOnModule(Module &M);


Index: llvm-poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp
diff -u llvm-poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp:1.57 llvm-poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp:1.58
--- llvm-poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp:1.57	Tue Oct 24 16:43:50 2006
+++ llvm-poolalloc/lib/PoolAllocate/TransformFunctionBody.cpp	Wed Dec 13 14:06:42 2006
@@ -149,7 +149,7 @@
   std::string Name = I->getName(); I->setName("");
 
   if (Size->getType() != Type::UIntTy)
-    Size = new CastInst(Size, Type::UIntTy, Size->getName(), I);
+    Size = CastInst::createZExtOrBitCast(Size, Type::UIntTy, Size->getName(), I);
 
   // Insert a call to poolalloc
   Value *PH = getPoolHandle(I);
@@ -162,7 +162,7 @@
   // Cast to the appropriate type if necessary
   Instruction *Casted = V;
   if (V->getType() != I->getType())
-    Casted = new CastInst(V, I->getType(), V->getName(), I);
+    Casted = CastInst::createPointerCast(V, I->getType(), V->getName(), I);
     
   // Update def-use info
   I->replaceAllUsesWith(Casted);
@@ -218,7 +218,7 @@
     Value *Casted = AI;
     Instruction *aiNext = AI->getNext();
     if (AI->getType() != PointerType::get(Type::SByteTy))
-      Casted = new CastInst(AI, PointerType::get(Type::SByteTy),
+      Casted = CastInst::createPointerCast(AI, PointerType::get(Type::SByteTy),
 			      AI->getName()+".casted",aiNext);
     
     Instruction *V = new CallInst(PAInfo.PoolRegister,
@@ -246,7 +246,7 @@
 					 MI.getOperand(0), "sizetmp", &MI);
     
     //  TransformAllocationInstr(&MI, AllocSize);
-    Instruction *Casted = new CastInst(&MI, PointerType::get(Type::SByteTy),
+    Instruction *Casted = CastInst::createPointerCast(&MI, PointerType::get(Type::SByteTy),
 				       MI.getName()+".casted", MI.getNext());
     Instruction *V = new CallInst(PAInfo.PoolRegister,
 				  make_vector(PH, Casted, AllocSize, 0), "", Casted->getNext());
@@ -263,7 +263,7 @@
   // Insert a cast and a call to poolfree...
   Value *Casted = Arg;
   if (Arg->getType() != PointerType::get(Type::SByteTy)) {
-    Casted = new CastInst(Arg, PointerType::get(Type::SByteTy),
+    Casted = CastInst::createPointerCast(Arg, PointerType::get(Type::SByteTy),
 				 Arg->getName()+".casted", Where);
     G.getScalarMap()[Casted] = G.getScalarMap()[Arg];
   }
@@ -302,14 +302,14 @@
   Value *V1 = CS.getArgument(0);
   Value *V2 = CS.getArgument(1);
   if (V1->getType() != V2->getType()) {
-    V1 = new CastInst(V1, useLong ? Type::ULongTy : Type::UIntTy, V1->getName(), CS.getInstruction());
-    V2 = new CastInst(V2, useLong ? Type::ULongTy : Type::UIntTy, V2->getName(), CS.getInstruction());
+    V1 = CastInst::createZExtOrBitCast(V1, useLong ? Type::ULongTy : Type::UIntTy, V1->getName(), CS.getInstruction());
+    V2 = CastInst::createZExtOrBitCast(V2, useLong ? Type::ULongTy : Type::UIntTy, V2->getName(), CS.getInstruction());
   }
 
   V2 = BinaryOperator::create(Instruction::Mul, V1, V2, "size",
                               CS.getInstruction());
   if (V2->getType() != (useLong ? Type::ULongTy : Type::UIntTy))
-    V2 = new CastInst(V2, useLong ? Type::ULongTy : Type::UIntTy, V2->getName(), CS.getInstruction());
+    V2 = CastInst::createZExtOrBitCast(V2, useLong ? Type::ULongTy : Type::UIntTy, V2->getName(), CS.getInstruction());
 
   BasicBlock::iterator BBI =
     TransformAllocationInstr(CS.getInstruction(), V2);
@@ -324,7 +324,7 @@
                                              Type::UIntTy, NULL);
 
   if (Ptr->getType() != PointerType::get(Type::SByteTy))
-    Ptr = new CastInst(Ptr, PointerType::get(Type::SByteTy), Ptr->getName(),
+    Ptr = CastInst::createPointerCast(Ptr, PointerType::get(Type::SByteTy), Ptr->getName(),
                        BBI);
   
   // We know that the memory returned by poolalloc is at least 4 byte aligned.
@@ -342,11 +342,11 @@
   Value *Size = CS.getArgument(1);
 
   if (Size->getType() != Type::UIntTy)
-    Size = new CastInst(Size, Type::UIntTy, Size->getName(), I);
+    Size = CastInst::createZExtOrBitCast(Size, Type::UIntTy, Size->getName(), I);
 
   static Type *VoidPtrTy = PointerType::get(Type::SByteTy);
   if (OldPtr->getType() != VoidPtrTy)
-    OldPtr = new CastInst(OldPtr, VoidPtrTy, OldPtr->getName(), I);
+    OldPtr = CastInst::createPointerCast(OldPtr, VoidPtrTy, OldPtr->getName(), I);
 
   std::string Name = I->getName(); I->setName("");
   Instruction *V = new CallInst(PAInfo.PoolRealloc, make_vector(PH, OldPtr,
@@ -354,7 +354,7 @@
                                 Name, I);
   Instruction *Casted = V;
   if (V->getType() != I->getType())
-    Casted = new CastInst(V, I->getType(), V->getName(), I);
+    Casted = CastInst::createPointerCast(V, I->getType(), V->getName(), I);
 
   // Update def-use info
   I->replaceAllUsesWith(Casted);
@@ -409,13 +409,13 @@
 
     static const Type *PtrPtr=PointerType::get(PointerType::get(Type::SByteTy));
     if (ResultDest->getType() != PtrPtr)
-      ResultDest = new CastInst(ResultDest, PtrPtr, ResultDest->getName(), I);
+      ResultDest = CastInst::createPointerCast(ResultDest, PtrPtr, ResultDest->getName(), I);
   }
 
   if (Align->getType() != Type::UIntTy)
-    Align = new CastInst(Align, Type::UIntTy, Align->getName(), I);
+    Align = CastInst::createZExtOrBitCast(Align, Type::UIntTy, Align->getName(), I);
   if (Size->getType() != Type::UIntTy)
-    Size = new CastInst(Size, Type::UIntTy, Size->getName(), I);
+    Size = CastInst::createZExtOrBitCast(Size, Type::UIntTy, Size->getName(), I);
 
   std::string Name = I->getName(); I->setName("");
   Instruction *V = new CallInst(PAInfo.PoolMemAlign,
@@ -423,7 +423,7 @@
 
   Instruction *Casted = V;
   if (V->getType() != I->getType())
-    Casted = new CastInst(V, I->getType(), V->getName(), I);
+    Casted = CastInst::createPointerCast(V, I->getType(), V->getName(), I);
 
   if (ResultDest)
     new StoreInst(V, ResultDest, I);
@@ -456,8 +456,11 @@
   Function *CF = CS.getCalledFunction();
   Instruction *TheCall = CS.getInstruction();
 
+  // If the called function is casted from one function type to another, peer
+  // into the cast instruction and pull out the actual function being called.
   if (ConstantExpr *CE = dyn_cast<ConstantExpr>(CS.getCalledValue()))
-    if (CE->getOpcode() == Instruction::Cast && isa<Function>(CE->getOperand(0)))
+    if (CE->getOpcode() == Instruction::BitCast &&
+        isa<Function>(CE->getOperand(0)))
       CF = cast<Function>(CE->getOperand(0));
 
   if (isa<InlineAsm>(TheCall->getOperand(0))) {
@@ -601,7 +604,7 @@
     PointerType *PFTy = PointerType::get(FTy);
     
     // If there are any pool arguments cast the func ptr to the right type.
-    NewCallee = new CastInst(CS.getCalledValue(), PFTy, "tmp", TheCall);
+    NewCallee = CastInst::createPointerCast(CS.getCalledValue(), PFTy, "tmp", TheCall);
   }
 
   Function::arg_iterator FAI = CF->arg_begin(), E = CF->arg_end();






More information about the llvm-commits mailing list