Revert yesterday's change by removing the LLVMContext parameter to AllocaInst and...

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@75863 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h
index b20ac18f41d756c3c248ae7a7ef61472bb54f0b2..6fa434cccfad5ecaafb4d92abd833d15118d8ad7 100644 (file)
--- a/include/llvm/Instructions.h
+++ b/include/llvm/Instructions.h
@@ -40,12 +40,10 @@ class LLVMContext;
 ///
 class AllocationInst : public UnaryInstruction {
 protected:
-  LLVMContext &Context;
-
-  AllocationInst(LLVMContext &Context, const Type *Ty, Value *ArraySize, 
+  AllocationInst(const Type *Ty, Value *ArraySize, 
                  unsigned iTy, unsigned Align, const std::string &Name = "", 
                  Instruction *InsertBefore = 0);
-  AllocationInst(LLVMContext &Context, const Type *Ty, Value *ArraySize,
+  AllocationInst(const Type *Ty, Value *ArraySize,
                  unsigned iTy, unsigned Align, const std::string &Name,
                  BasicBlock *InsertAtEnd);
 public:
@@ -103,32 +101,31 @@ public:
 class MallocInst : public AllocationInst {
   MallocInst(const MallocInst &MI);
 public:
-  explicit MallocInst(LLVMContext &Context, 
-                      const Type *Ty, Value *ArraySize = 0,
+  explicit MallocInst(const Type *Ty, Value *ArraySize = 0,
                       const std::string &NameStr = "",
                       Instruction *InsertBefore = 0)
-    : AllocationInst(Context, Ty, ArraySize, Malloc,
+    : AllocationInst(Ty, ArraySize, Malloc,
                      0, NameStr, InsertBefore) {}
-  MallocInst(LLVMContext &Context, const Type *Ty, Value *ArraySize,
+  MallocInst(const Type *Ty, Value *ArraySize,
              const std::string &NameStr, BasicBlock *InsertAtEnd)
-    : AllocationInst(Context, Ty, ArraySize, Malloc, 0, NameStr, InsertAtEnd) {}
+    : AllocationInst(Ty, ArraySize, Malloc, 0, NameStr, InsertAtEnd) {}
 
-  MallocInst(LLVMContext &Context, const Type *Ty, const std::string &NameStr,
+  MallocInst(const Type *Ty, const std::string &NameStr,
              Instruction *InsertBefore = 0)
-    : AllocationInst(Context, Ty, 0, Malloc, 0, NameStr, InsertBefore) {}
-  MallocInst(LLVMContext &Context, const Type *Ty, const std::string &NameStr,
+    : AllocationInst(Ty, 0, Malloc, 0, NameStr, InsertBefore) {}
+  MallocInst(const Type *Ty, const std::string &NameStr,
              BasicBlock *InsertAtEnd)
-    : AllocationInst(Context, Ty, 0, Malloc, 0, NameStr, InsertAtEnd) {}
+    : AllocationInst(Ty, 0, Malloc, 0, NameStr, InsertAtEnd) {}
 
-  MallocInst(LLVMContext &Context, const Type *Ty, Value *ArraySize,
+  MallocInst(const Type *Ty, Value *ArraySize,
              unsigned Align, const std::string &NameStr,
              BasicBlock *InsertAtEnd)
-    : AllocationInst(Context, Ty, ArraySize, Malloc,
+    : AllocationInst(Ty, ArraySize, Malloc,
                      Align, NameStr, InsertAtEnd) {}
-  MallocInst(LLVMContext &Context, const Type *Ty, Value *ArraySize,
+  MallocInst(const Type *Ty, Value *ArraySize,
              unsigned Align, const std::string &NameStr = "", 
              Instruction *InsertBefore = 0)
-    : AllocationInst(Context, Ty, ArraySize,
+    : AllocationInst(Ty, ArraySize,
                      Malloc, Align, NameStr, InsertBefore) {}
 
   virtual MallocInst *clone(LLVMContext &Context) const;
@@ -153,33 +150,33 @@ public:
 class AllocaInst : public AllocationInst {
   AllocaInst(const AllocaInst &);
 public:
-  explicit AllocaInst(LLVMContext &Context, const Type *Ty,
+  explicit AllocaInst(const Type *Ty,
                       Value *ArraySize = 0,
                       const std::string &NameStr = "",
                       Instruction *InsertBefore = 0)
-    : AllocationInst(Context, Ty, ArraySize, Alloca,
+    : AllocationInst(Ty, ArraySize, Alloca,
                      0, NameStr, InsertBefore) {}
-  AllocaInst(LLVMContext &Context, const Type *Ty,
+  AllocaInst(const Type *Ty,
              Value *ArraySize, const std::string &NameStr,
              BasicBlock *InsertAtEnd)
-    : AllocationInst(Context, Ty, ArraySize, Alloca, 0, NameStr, InsertAtEnd) {}
+    : AllocationInst(Ty, ArraySize, Alloca, 0, NameStr, InsertAtEnd) {}
 
-  AllocaInst(LLVMContext &Context, const Type *Ty, const std::string &NameStr,
+  AllocaInst(const Type *Ty, const std::string &NameStr,
              Instruction *InsertBefore = 0)
-    : AllocationInst(Context, Ty, 0, Alloca, 0, NameStr, InsertBefore) {}
-  AllocaInst(LLVMContext &Context, const Type *Ty, const std::string &NameStr,
+    : AllocationInst(Ty, 0, Alloca, 0, NameStr, InsertBefore) {}
+  AllocaInst(const Type *Ty, const std::string &NameStr,
              BasicBlock *InsertAtEnd)
-    : AllocationInst(Context, Ty, 0, Alloca, 0, NameStr, InsertAtEnd) {}
+    : AllocationInst(Ty, 0, Alloca, 0, NameStr, InsertAtEnd) {}
 
-  AllocaInst(LLVMContext &Context, const Type *Ty, Value *ArraySize,
+  AllocaInst(const Type *Ty, Value *ArraySize,
              unsigned Align, const std::string &NameStr = "",
              Instruction *InsertBefore = 0)
-    : AllocationInst(Context, Ty, ArraySize, Alloca,
+    : AllocationInst(Ty, ArraySize, Alloca,
                      Align, NameStr, InsertBefore) {}
-  AllocaInst(LLVMContext &Context, const Type *Ty, Value *ArraySize,
+  AllocaInst(const Type *Ty, Value *ArraySize,
              unsigned Align, const std::string &NameStr,
              BasicBlock *InsertAtEnd)
-    : AllocationInst(Context, Ty, ArraySize, Alloca,
+    : AllocationInst(Ty, ArraySize, Alloca,
                      Align, NameStr, InsertAtEnd) {}
 
   virtual AllocaInst *clone(LLVMContext &Context) const;

diff --git a/include/llvm/Support/IRBuilder.h b/include/llvm/Support/IRBuilder.h
index cd0e1826b004fac94c7306375b941e93826ef521..2ef13a789f30444abedcebb1781416b031d198e4 100644 (file)
--- a/include/llvm/Support/IRBuilder.h
+++ b/include/llvm/Support/IRBuilder.h
@@ -330,11 +330,11 @@ public:
 
   MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
                            const char *Name = "") {
-    return Insert(new MallocInst(Context, Ty, ArraySize), Name);
+    return Insert(new MallocInst(Ty, ArraySize), Name);
   }
   AllocaInst *CreateAlloca(const Type *Ty, Value *ArraySize = 0,
                            const char *Name = "") {
-    return Insert(new AllocaInst(Context, Ty, ArraySize), Name);
+    return Insert(new AllocaInst(Ty, ArraySize), Name);
   }
   FreeInst *CreateFree(Value *Ptr) {
     return Insert(new FreeInst(Ptr));

diff --git a/include/llvm/Transforms/Utils/Local.h b/include/llvm/Transforms/Utils/Local.h
index 35f2a69f47a55680fa697afeb091c5a6a6bf4dbb..32e7ae81b1b757bae6f7d7f9169cba32e2e97023 100644 (file)
--- a/include/llvm/Transforms/Utils/Local.h
+++ b/include/llvm/Transforms/Utils/Local.h
@@ -108,15 +108,14 @@ bool FoldBranchToCommonDest(BranchInst *BI);
 /// invalidating the SSA information for the value.  It returns the pointer to
 /// the alloca inserted to create a stack slot for X.
 ///
-AllocaInst *DemoteRegToStack(LLVMContext &Context, Instruction &X,
+AllocaInst *DemoteRegToStack(Instruction &X,
                              bool VolatileLoads = false,
                              Instruction *AllocaPoint = 0);
 
 /// DemotePHIToStack - This function takes a virtual register computed by a phi
 /// node and replaces it with a slot in the stack frame, allocated via alloca.
 /// The phi node is deleted and it returns the pointer to the alloca inserted. 
-AllocaInst *DemotePHIToStack(LLVMContext &Context, PHINode *P,
-                             Instruction *AllocaPoint = 0);
+AllocaInst *DemotePHIToStack(PHINode *P, Instruction *AllocaPoint = 0);
 
 /// OnlyUsedByDbgIntrinsics - Return true if the instruction I is only used
 /// by DbgIntrinsics. If DbgInUses is specified then the vector is filled 

diff --git a/lib/AsmParser/LLParser.cpp b/lib/AsmParser/LLParser.cpp
index 1c8156adcf8d5f4504db868c048bc125e5e8f8dc..080575df84a68fcdbc4f6d9e798deec5361db35e 100644 (file)
--- a/lib/AsmParser/LLParser.cpp
+++ b/lib/AsmParser/LLParser.cpp
@@ -3182,9 +3182,9 @@ bool LLParser::ParseAlloc(Instruction *&Inst, PerFunctionState &PFS,
     return Error(SizeLoc, "element count must be i32");
 
   if (Opc == Instruction::Malloc)
-    Inst = new MallocInst(Context, Ty, Size, Alignment);
+    Inst = new MallocInst(Ty, Size, Alignment);
   else
-    Inst = new AllocaInst(Context, Ty, Size, Alignment);
+    Inst = new AllocaInst(Ty, Size, Alignment);
   return false;
 }
 

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index b15355a8ca3d02a83d34d475c610643f6e5326e7..e4d3c5e1ade85cef16052a174f4aed1ea49a6a04 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1817,8 +1817,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
       unsigned Align = Record[2];
       if (!Ty || !Size) return Error("Invalid MALLOC record");
-      I = new MallocInst(Context, Ty->getElementType(), Size,
-                         (1 << Align) >> 1);
+      I = new MallocInst(Ty->getElementType(), Size, (1 << Align) >> 1);
       break;
     }
     case bitc::FUNC_CODE_INST_FREE: { // FREE: [op, opty]
@@ -1838,8 +1837,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       Value *Size = getFnValueByID(Record[1], Type::Int32Ty);
       unsigned Align = Record[2];
       if (!Ty || !Size) return Error("Invalid ALLOCA record");
-      I = new AllocaInst(Context, Ty->getElementType(), Size,
-                         (1 << Align) >> 1);
+      I = new AllocaInst(Ty->getElementType(), Size, (1 << Align) >> 1);
       break;
     }
     case bitc::FUNC_CODE_INST_LOAD: { // LOAD: [opty, op, align, vol]

diff --git a/lib/CodeGen/DwarfEHPrepare.cpp b/lib/CodeGen/DwarfEHPrepare.cpp
index 5fa8dcea3467992f9563e54bb9cb12328a2e464f..3691ba0773a3d80f85cb599426b0867e48845d4d 100644 (file)
--- a/lib/CodeGen/DwarfEHPrepare.cpp
+++ b/lib/CodeGen/DwarfEHPrepare.cpp
@@ -354,8 +354,8 @@ Instruction *DwarfEHPrepare::CreateValueLoad(BasicBlock *BB) {
 
   // Create the temporary if we didn't already.
   if (!ExceptionValueVar) {
-    ExceptionValueVar = new AllocaInst(*Context, 
-                                       PointerType::getUnqual(Type::Int8Ty),
+    ExceptionValueVar = new AllocaInst(
+                                    Context->getPointerTypeUnqual(Type::Int8Ty),
                                        "eh.value", F->begin()->begin());
     ++NumStackTempsIntroduced;
   }

diff --git a/lib/CodeGen/StackProtector.cpp b/lib/CodeGen/StackProtector.cpp
index 3dce50b1a85c7df7b2584776bd5bc61bb3863fc5..9043b89e354e8650265295defe23e23d055bddc0 100644 (file)
--- a/lib/CodeGen/StackProtector.cpp
+++ b/lib/CodeGen/StackProtector.cpp
@@ -154,7 +154,7 @@ bool StackProtector::InsertStackProtectors() {
       BasicBlock &Entry = F->getEntryBlock();
       Instruction *InsPt = &Entry.front();
 
-      AI = new AllocaInst(*Context, PtrTy, "StackGuardSlot", InsPt);
+      AI = new AllocaInst(PtrTy, "StackGuardSlot", InsPt);
       LoadInst *LI = new LoadInst(StackGuardVar, "StackGuard", false, InsPt);
 
       Value *Args[] = { LI, AI };

diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp
index 7f1c3cb21607997ee7025ffce606b496cb6797c8..75a0415fadf50700017b63b41b76a900c437f381 100644 (file)
--- a/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -755,7 +755,7 @@ Function *ArgPromotion::DoPromotion(Function *F,
 
       // Just add all the struct element types.
       const Type *AgTy = cast<PointerType>(I->getType())->getElementType();
-      Value *TheAlloca = new AllocaInst(*Context, AgTy, 0, "", InsertPt);
+      Value *TheAlloca = new AllocaInst(AgTy, 0, "", InsertPt);
       const StructType *STy = cast<StructType>(AgTy);
       Value *Idxs[2] = { Context->getConstantInt(Type::Int32Ty, 0), 0 };
 

diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index 13fe94af31addb56879bdf6c3b06aaeeb5d21eb5..398f78a0984200ebe91cb1c0270fbb2a475ddd1e 100644 (file)
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -828,7 +828,7 @@ static GlobalVariable *OptimizeGlobalAddressOfMalloc(GlobalVariable *GV,
     Type *NewTy = Context->getArrayType(MI->getAllocatedType(),
                                  NElements->getZExtValue());
     MallocInst *NewMI =
-      new MallocInst(*Context, NewTy, Context->getNullValue(Type::Int32Ty),
+      new MallocInst(NewTy, Context->getNullValue(Type::Int32Ty),
                      MI->getAlignment(), MI->getName(), MI);
     Value* Indices[2];
     Indices[0] = Indices[1] = Context->getNullValue(Type::Int32Ty);
@@ -1291,7 +1291,7 @@ static GlobalVariable *PerformHeapAllocSRoA(GlobalVariable *GV, MallocInst *MI,
                          GV->isThreadLocal());
     FieldGlobals.push_back(NGV);
     
-    MallocInst *NMI = new MallocInst(*Context, FieldTy, MI->getArraySize(),
+    MallocInst *NMI = new MallocInst(FieldTy, MI->getArraySize(),
                                      MI->getName() + ".f" + utostr(FieldNo),MI);
     FieldMallocs.push_back(NMI);
     new StoreInst(NMI, NGV, MI);
@@ -1507,7 +1507,7 @@ static bool TryToOptimizeStoreOfMallocToGlobal(GlobalVariable *GV,
       // structs.  malloc [100 x struct],1 -> malloc struct, 100
       if (const ArrayType *AT = dyn_cast<ArrayType>(MI->getAllocatedType())) {
         MallocInst *NewMI = 
-          new MallocInst(*Context, AllocSTy, 
+          new MallocInst(AllocSTy, 
                   Context->getConstantInt(Type::Int32Ty, AT->getNumElements()),
                          "", MI);
         NewMI->takeName(MI);
@@ -1703,8 +1703,7 @@ bool GlobalOpt::ProcessInternalGlobal(GlobalVariable *GV,
       Instruction* FirstI = GS.AccessingFunction->getEntryBlock().begin();
       const Type* ElemTy = GV->getType()->getElementType();
       // FIXME: Pass Global's alignment when globals have alignment
-      AllocaInst* Alloca = new AllocaInst(*Context, ElemTy, NULL,
-                                          GV->getName(), FirstI);
+      AllocaInst* Alloca = new AllocaInst(ElemTy, NULL, GV->getName(), FirstI);
       if (!isa<UndefValue>(GV->getInitializer()))
         new StoreInst(GV->getInitializer(), Alloca, FirstI);
 

diff --git a/lib/Transforms/IPO/IndMemRemoval.cpp b/lib/Transforms/IPO/IndMemRemoval.cpp
index d3e609dd82049c178cdb30fed84e59d6c7146280..2086a166833f5add8e855ab4755b6be85df88734 100644 (file)
--- a/lib/Transforms/IPO/IndMemRemoval.cpp
+++ b/lib/Transforms/IPO/IndMemRemoval.cpp
@@ -73,7 +73,7 @@ bool IndMemRemPass::runOnModule(Module &M) {
       BasicBlock* bb = BasicBlock::Create("entry",FN);
       Instruction* c = CastInst::CreateIntegerCast(
           FN->arg_begin(), Type::Int32Ty, false, "c", bb);
-      Instruction* a = new MallocInst(*Context, Type::Int8Ty, c, "m", bb);
+      Instruction* a = new MallocInst(Type::Int8Ty, c, "m", bb);
       ReturnInst::Create(a, bb);
       ++NumBounce;
       NumBounceSites += F->getNumUses();

diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp
index 8f5d50d3b69f4783ad38b472b074183a66b4189d..dfdf5b6f2d4d28c16d7f51f4f34c16de9dcd2238 100644 (file)
--- a/lib/Transforms/IPO/LowerSetJmp.cpp
+++ b/lib/Transforms/IPO/LowerSetJmp.cpp
@@ -311,7 +311,7 @@ AllocaInst* LowerSetJmp::GetSetJmpMap(Function* Func)
 
   // Fill in the alloca and call to initialize the SJ map.
   const Type *SBPTy = Context->getPointerTypeUnqual(Type::Int8Ty);
-  AllocaInst* Map = new AllocaInst(*Context, SBPTy, 0, "SJMap", Inst);
+  AllocaInst* Map = new AllocaInst(SBPTy, 0, "SJMap", Inst);
   CallInst::Create(InitSJMap, Map, "", Inst);
   return SJMap[Func] = Map;
 }
@@ -408,7 +408,7 @@ void LowerSetJmp::TransformSetJmpCall(CallInst* Inst)
          UI != E; ++UI)
       if (cast<Instruction>(*UI)->getParent() != ABlock ||
           InstrsAfterCall.count(cast<Instruction>(*UI))) {
-        DemoteRegToStack(*Context, *II);
+        DemoteRegToStack(*II);
         break;
       }
   InstrsAfterCall.clear();

diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp
index ce976c8d69ea910c458bd77393cc47283071d275..6c32050909738ce43fccbe8db24464d382ef5090 100644 (file)
--- a/lib/Transforms/IPO/RaiseAllocations.cpp
+++ b/lib/Transforms/IPO/RaiseAllocations.cpp
@@ -169,8 +169,7 @@ bool RaiseAllocations::runOnModule(Module &M) {
               CastInst::CreateIntegerCast(Source, Type::Int32Ty, false/*ZExt*/,
                                           "MallocAmtCast", I);
 
-          MallocInst *MI = new MallocInst(*Context, Type::Int8Ty,
-                                          Source, "", I);
+          MallocInst *MI = new MallocInst(Type::Int8Ty, Source, "", I);
           MI->takeName(I);
           I->replaceAllUsesWith(MI);
 

diff --git a/lib/Transforms/IPO/StructRetPromotion.cpp b/lib/Transforms/IPO/StructRetPromotion.cpp
index 7771bc4b74d0eaa4b69bc4320aa435186137951d..933bbb05783f6d6ace573f58a3ae0d1cb6be5923 100644 (file)
--- a/lib/Transforms/IPO/StructRetPromotion.cpp
+++ b/lib/Transforms/IPO/StructRetPromotion.cpp
@@ -110,8 +110,8 @@ bool SRETPromotion::PromoteReturn(CallGraphNode *CGN) {
   DOUT << "SretPromotion: sret argument will be promoted\n";
   NumSRET++;
   // [1] Replace use of sret parameter 
-  AllocaInst *TheAlloca = new AllocaInst (*Context, STy, NULL, "mrv", 
-                                          F->getEntryBlock().begin());
+  AllocaInst *TheAlloca = new AllocaInst(STy, NULL, "mrv", 
+                                         F->getEntryBlock().begin());
   Value *NFirstArg = F->arg_begin();
   NFirstArg->replaceAllUsesWith(TheAlloca);
 

diff --git a/lib/Transforms/Instrumentation/RSProfiling.cpp b/lib/Transforms/Instrumentation/RSProfiling.cpp
index ad76ba448077bebae0451c43b56a66ee16508f97..36b446431133f72bfc7a51d51b92f4a860772c54 100644 (file)
--- a/lib/Transforms/Instrumentation/RSProfiling.cpp
+++ b/lib/Transforms/Instrumentation/RSProfiling.cpp
@@ -248,7 +248,7 @@ void GlobalRandomCounterOpt::PrepFunction(Function* F) {
   //make a local temporary to cache the global
   BasicBlock& bb = F->getEntryBlock();
   BasicBlock::iterator InsertPt = bb.begin();
-  AI = new AllocaInst(*F->getContext(), T, 0, "localcounter", InsertPt);
+  AI = new AllocaInst(T, 0, "localcounter", InsertPt);
   LoadInst* l = new LoadInst(Counter, "counterload", InsertPt);
   new StoreInst(l, AI, InsertPt);
   

diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index fd87e30f96303f52e31afb3ead51b19f089655bb..2b7ca6bbaaa62bf18c2800c8b3722f081532054e 100644 (file)
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -7891,9 +7891,9 @@ Instruction *InstCombiner::PromoteCastOfAllocation(BitCastInst &CI,
   
   AllocationInst *New;
   if (isa<MallocInst>(AI))
-    New = new MallocInst(*Context, CastElTy, Amt, AI.getAlignment());
+    New = new MallocInst(CastElTy, Amt, AI.getAlignment());
   else
-    New = new AllocaInst(*Context, CastElTy, Amt, AI.getAlignment());
+    New = new AllocaInst(CastElTy, Amt, AI.getAlignment());
   InsertNewInstBefore(New, AI);
   New->takeName(&AI);
   
@@ -11368,12 +11368,10 @@ Instruction *InstCombiner::visitAllocationInst(AllocationInst &AI) {
 
       // Create and insert the replacement instruction...
       if (isa<MallocInst>(AI))
-        New = new MallocInst(*Context, NewTy, 0,
-                             AI.getAlignment(), AI.getName());
+        New = new MallocInst(NewTy, 0, AI.getAlignment(), AI.getName());
       else {
         assert(isa<AllocaInst>(AI) && "Unknown type of allocation inst!");
-        New = new AllocaInst(*Context, NewTy, 0,
-                             AI.getAlignment(), AI.getName());
+        New = new AllocaInst(NewTy, 0, AI.getAlignment(), AI.getName());
       }
 
       InsertNewInstBefore(New, AI);

diff --git a/lib/Transforms/Scalar/JumpThreading.cpp b/lib/Transforms/Scalar/JumpThreading.cpp
index 86e03c47f6a872541f678b20339eb1b41d47cc87..f3536c10c5756026dbd80355f011602882aae029 100644 (file)
--- a/lib/Transforms/Scalar/JumpThreading.cpp
+++ b/lib/Transforms/Scalar/JumpThreading.cpp
@@ -912,7 +912,7 @@ bool JumpThreading::ThreadEdge(BasicBlock *BB, BasicBlock *PredBB,
     
     // We found a use of I outside of BB.  Create a new stack slot to
     // break this inter-block usage pattern.
-    DemoteRegToStack(*Context, *I);
+    DemoteRegToStack(*I);
   }
  
   // We are going to have to map operands from the original BB block to the new

diff --git a/lib/Transforms/Scalar/LICM.cpp b/lib/Transforms/Scalar/LICM.cpp
index aa49b24aba90de9c382f11ea72b3c71524b0291c..52dd06affe5fcf2ed46340d18f587fbfc42931f7 100644 (file)
--- a/lib/Transforms/Scalar/LICM.cpp
+++ b/lib/Transforms/Scalar/LICM.cpp
@@ -508,7 +508,7 @@ void LICM::sink(Instruction &I) {
     AllocaInst *AI = 0;
 
     if (I.getType() != Type::VoidTy) {
-      AI = new AllocaInst(*Context, I.getType(), 0, I.getName(),
+      AI = new AllocaInst(I.getType(), 0, I.getName(),
                           I.getParent()->getParent()->getEntryBlock().begin());
       CurAST->add(AI);
     }
@@ -853,8 +853,7 @@ void LICM::FindPromotableValuesInLoop(
       continue;
     
     const Type *Ty = cast<PointerType>(V->getType())->getElementType();
-    AllocaInst *AI = new AllocaInst(*Context, Ty, 0,
-                                    V->getName()+".tmp", FnStart);
+    AllocaInst *AI = new AllocaInst(Ty, 0, V->getName()+".tmp", FnStart);
     PromotedValues.push_back(std::make_pair(AI, V));
 
     // Update the AST and alias analysis.

diff --git a/lib/Transforms/Scalar/Reg2Mem.cpp b/lib/Transforms/Scalar/Reg2Mem.cpp
index 289f08c94752e3d92e098ce457a829655aa94a93..ac95d25b7f7fba65a32b89a0876d61c77aa309e8 100644 (file)
--- a/lib/Transforms/Scalar/Reg2Mem.cpp
+++ b/lib/Transforms/Scalar/Reg2Mem.cpp
@@ -89,7 +89,7 @@ namespace {
         NumRegsDemoted += worklist.size();
         for (std::list<Instruction*>::iterator ilb = worklist.begin(), 
                ile = worklist.end(); ilb != ile; ++ilb)
-          DemoteRegToStack(*Context, **ilb, false, AllocaInsertionPoint);
+          DemoteRegToStack(**ilb, false, AllocaInsertionPoint);
 
         worklist.clear();
 
@@ -105,7 +105,7 @@ namespace {
         NumPhisDemoted += worklist.size();
         for (std::list<Instruction*>::iterator ilb = worklist.begin(), 
                ile = worklist.end(); ilb != ile; ++ilb)
-          DemotePHIToStack(*Context, cast<PHINode>(*ilb), AllocaInsertionPoint);
+          DemotePHIToStack(cast<PHINode>(*ilb), AllocaInsertionPoint);
 
         return true;
       }

diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index d999f9d8a948795e0bdc1aa839567f137e28a6c4..7df4eb6818f37f416c1ac6d5ac55a54b7b59170d 100644 (file)
--- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp
+++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
@@ -302,16 +302,14 @@ bool SROA::performScalarRepl(Function &F) {
         DOUT << "CONVERT TO VECTOR: " << *AI << "  TYPE = " << *VectorTy <<"\n";
         
         // Create and insert the vector alloca.
-        NewAI = new AllocaInst(*Context, VectorTy, 0, "", 
-                               AI->getParent()->begin());
+        NewAI = new AllocaInst(VectorTy, 0, "",  AI->getParent()->begin());
         ConvertUsesToScalar(AI, NewAI, 0);
       } else {
         DOUT << "CONVERT TO SCALAR INTEGER: " << *AI << "\n";
         
         // Create and insert the integer alloca.
         const Type *NewTy = Context->getIntegerType(AllocaSize*8);
-        NewAI = new AllocaInst(*Context, NewTy, 0, "", 
-                               AI->getParent()->begin());
+        NewAI = new AllocaInst(NewTy, 0, "", AI->getParent()->begin());
         ConvertUsesToScalar(AI, NewAI, 0);
       }
       NewAI->takeName(AI);
@@ -336,8 +334,7 @@ void SROA::DoScalarReplacement(AllocationInst *AI,
   if (const StructType *ST = dyn_cast<StructType>(AI->getAllocatedType())) {
     ElementAllocas.reserve(ST->getNumContainedTypes());
     for (unsigned i = 0, e = ST->getNumContainedTypes(); i != e; ++i) {
-      AllocaInst *NA = new AllocaInst(*Context,
-                                      ST->getContainedType(i), 0, 
+      AllocaInst *NA = new AllocaInst(ST->getContainedType(i), 0, 
                                       AI->getAlignment(),
                                       AI->getName() + "." + utostr(i), AI);
       ElementAllocas.push_back(NA);
@@ -348,7 +345,7 @@ void SROA::DoScalarReplacement(AllocationInst *AI,
     ElementAllocas.reserve(AT->getNumElements());
     const Type *ElTy = AT->getElementType();
     for (unsigned i = 0, e = AT->getNumElements(); i != e; ++i) {
-      AllocaInst *NA = new AllocaInst(*Context, ElTy, 0, AI->getAlignment(),
+      AllocaInst *NA = new AllocaInst(ElTy, 0, AI->getAlignment(),
                                       AI->getName() + "." + utostr(i), AI);
       ElementAllocas.push_back(NA);
       WorkList.push_back(NA);  // Add to worklist for recursive processing

diff --git a/lib/Transforms/Scalar/TailDuplication.cpp b/lib/Transforms/Scalar/TailDuplication.cpp
index 5f7221051c22c0d7a3f7eabd6e0bdd7f14793412..684b0963456ea5f2238a33be371f203f55e7db06 100644 (file)
--- a/lib/Transforms/Scalar/TailDuplication.cpp
+++ b/lib/Transforms/Scalar/TailDuplication.cpp
@@ -285,7 +285,7 @@ void TailDup::eliminateUnconditionalBranch(BranchInst *Branch) {
     if (I->isUsedOutsideOfBlock(DestBlock)) {
       // We found a use outside of the tail.  Create a new stack slot to
       // break this inter-block usage pattern.
-      DemoteRegToStack(*Context, *I);
+      DemoteRegToStack(*I);
     }
 
   // We are going to have to map operands from the original block B to the new

diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp
index 46e27c8c277df093066400ab1f49709b3366a07e..be02560de076bbe7f8a782b3e26f5f6bad22584a 100644 (file)
--- a/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/lib/Transforms/Utils/CodeExtractor.cpp
@@ -372,8 +372,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
       StructValues.push_back(*i);
     } else {
       AllocaInst *alloca =
-        new AllocaInst(*codeReplacer->getContext(), 
-                       (*i)->getType(), 0, (*i)->getName()+".loc",
+        new AllocaInst((*i)->getType(), 0, (*i)->getName()+".loc",
                        codeReplacer->getParent()->begin()->begin());
       ReloadOutputs.push_back(alloca);
       params.push_back(alloca);
@@ -390,7 +389,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
     // Allocate a struct at the beginning of this function
     Type *StructArgTy = Context->getStructType(ArgTypes);
     Struct =
-      new AllocaInst(*codeReplacer->getContext(), StructArgTy, 0, "structArg",
+      new AllocaInst(StructArgTy, 0, "structArg",
                      codeReplacer->getParent()->begin()->begin());
     params.push_back(Struct);
 

diff --git a/lib/Transforms/Utils/DemoteRegToStack.cpp b/lib/Transforms/Utils/DemoteRegToStack.cpp
index 6cf043b6a1f7e0387a08ce9fdbc9468f54e48f45..c908b4a55914266e041f9ddd00c6d92b05b38a4e 100644 (file)
--- a/lib/Transforms/Utils/DemoteRegToStack.cpp
+++ b/lib/Transforms/Utils/DemoteRegToStack.cpp
@@ -29,8 +29,7 @@ using namespace llvm;
 /// invalidating the SSA information for the value.  It returns the pointer to
 /// the alloca inserted to create a stack slot for I.
 ///
-AllocaInst* llvm::DemoteRegToStack(LLVMContext &Context, 
-                                   Instruction &I, bool VolatileLoads,
+AllocaInst* llvm::DemoteRegToStack(Instruction &I, bool VolatileLoads,
                                    Instruction *AllocaPoint) {
   if (I.use_empty()) {
     I.eraseFromParent();
@@ -40,11 +39,11 @@ AllocaInst* llvm::DemoteRegToStack(LLVMContext &Context,
   // Create a stack slot to hold the value.
   AllocaInst *Slot;
   if (AllocaPoint) {
-    Slot = new AllocaInst(Context, I.getType(), 0,
+    Slot = new AllocaInst(I.getType(), 0,
                           I.getName()+".reg2mem", AllocaPoint);
   } else {
     Function *F = I.getParent()->getParent();
-    Slot = new AllocaInst(Context, I.getType(), 0, I.getName()+".reg2mem",
+    Slot = new AllocaInst(I.getType(), 0, I.getName()+".reg2mem",
                           F->getEntryBlock().begin());
   }
   
@@ -109,8 +108,7 @@ AllocaInst* llvm::DemoteRegToStack(LLVMContext &Context,
 /// DemotePHIToStack - This function takes a virtual register computed by a phi
 /// node and replaces it with a slot in the stack frame, allocated via alloca.
 /// The phi node is deleted and it returns the pointer to the alloca inserted.
-AllocaInst* llvm::DemotePHIToStack(LLVMContext &Context, PHINode *P,
-                                   Instruction *AllocaPoint) {
+AllocaInst* llvm::DemotePHIToStack(PHINode *P, Instruction *AllocaPoint) {
   if (P->use_empty()) {
     P->eraseFromParent();    
     return 0;                
@@ -119,11 +117,11 @@ AllocaInst* llvm::DemotePHIToStack(LLVMContext &Context, PHINode *P,
   // Create a stack slot to hold the value.
   AllocaInst *Slot;
   if (AllocaPoint) {
-    Slot = new AllocaInst(Context, P->getType(), 0,
+    Slot = new AllocaInst(P->getType(), 0,
                           P->getName()+".reg2mem", AllocaPoint);
   } else {
     Function *F = P->getParent()->getParent();
-    Slot = new AllocaInst(Context, P->getType(), 0, P->getName()+".reg2mem",
+    Slot = new AllocaInst(P->getType(), 0, P->getName()+".reg2mem",
                           F->getEntryBlock().begin());
   }
   

diff --git a/lib/Transforms/Utils/InlineFunction.cpp b/lib/Transforms/Utils/InlineFunction.cpp
index 30b1caaa4c58ccb786a17f5b568ed649a083d485..e1b493c204a38f25ae6f9f7957aaeaea8f9fa03f 100644 (file)
--- a/lib/Transforms/Utils/InlineFunction.cpp
+++ b/lib/Transforms/Utils/InlineFunction.cpp
@@ -309,7 +309,7 @@ bool llvm::InlineFunction(CallSite CS, CallGraph *CG, const TargetData *TD) {
         // Create the alloca.  If we have TargetData, use nice alignment.
         unsigned Align = 1;
         if (TD) Align = TD->getPrefTypeAlignment(AggTy);
-        Value *NewAlloca = new AllocaInst(*Context, AggTy, 0, Align, 
+        Value *NewAlloca = new AllocaInst(AggTy, 0, Align, 
                                           I->getName(), 
                                           &*Caller->begin()->begin());
         // Emit a memcpy.

diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp
index 8ba14392eca24fc7d79c98c875d73bb0a995c3a9..fae3edf0ada09d308fa1e93b71f8a6f72a80eb72 100644 (file)
--- a/lib/Transforms/Utils/LowerInvoke.cpp
+++ b/lib/Transforms/Utils/LowerInvoke.cpp
@@ -417,7 +417,7 @@ splitLiveRangesLiveAcrossInvokes(std::vector<InvokeInst*> &Invokes) {
       // If we decided we need a spill, do it.
       if (NeedsSpill) {
         ++NumSpilled;
-        DemoteRegToStack(*Context, *Inst, true);
+        DemoteRegToStack(*Inst, true);
       }
     }
 }
@@ -470,7 +470,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
     // alloca because the value needs to be live across invokes.
     unsigned Align = TLI ? TLI->getJumpBufAlignment() : 0;
     AllocaInst *JmpBuf =
-      new AllocaInst(*Context, JBLinkTy, 0, Align,
+      new AllocaInst(JBLinkTy, 0, Align,
                      "jblink", F.begin()->begin());
 
     std::vector<Value*> Idx;
@@ -494,7 +494,7 @@ bool LowerInvoke::insertExpensiveEHSupport(Function &F) {
 
     // Create an alloca which keeps track of which invoke is currently
     // executing.  For normal calls it contains zero.
-    AllocaInst *InvokeNum = new AllocaInst(*Context, Type::Int32Ty, 0,
+    AllocaInst *InvokeNum = new AllocaInst(Type::Int32Ty, 0,
                                            "invokenum",EntryBB->begin());
     new StoreInst(Context->getConstantInt(Type::Int32Ty, 0), InvokeNum, true,
                   EntryBB->getTerminator());

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 74bf42bc92fe810d7ca3a45818c2058573c52310..d2d0f509cc22ccd22e0b7fa96ba417160c7b70a8 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -712,25 +712,21 @@ static Value *getAISize(LLVMContext &Context, Value *Amt) {
   return Amt;
 }
 
-AllocationInst::AllocationInst(LLVMContext &C, 
-                               const Type *Ty, Value *ArraySize, unsigned iTy,
+AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
                                unsigned Align, const std::string &Name,
                                Instruction *InsertBefore)
-  : UnaryInstruction(PointerType::getUnqual(Ty), iTy,
-                     getAISize(Context, ArraySize), InsertBefore),
-    Context(C) {
+  : UnaryInstruction(Ty->getContext().getPointerTypeUnqual(Ty), iTy,
+                     getAISize(Ty->getContext(), ArraySize), InsertBefore) {
   setAlignment(Align);
   assert(Ty != Type::VoidTy && "Cannot allocate void!");
   setName(Name);
 }
 
-AllocationInst::AllocationInst(LLVMContext &C,
-                               const Type *Ty, Value *ArraySize, unsigned iTy,
+AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
                                unsigned Align, const std::string &Name,
                                BasicBlock *InsertAtEnd)
-  : UnaryInstruction(PointerType::getUnqual(Ty), iTy,
-                     getAISize(Context, ArraySize), InsertAtEnd),
-    Context(C) {
+  : UnaryInstruction(Ty->getContext().getPointerTypeUnqual(Ty), iTy,
+                     getAISize(Ty->getContext(), ArraySize), InsertAtEnd) {
   setAlignment(Align);
   assert(Ty != Type::VoidTy && "Cannot allocate void!");
   setName(Name);
@@ -757,7 +753,7 @@ const Type *AllocationInst::getAllocatedType() const {
 }
 
 AllocaInst::AllocaInst(const AllocaInst &AI)
-  : AllocationInst(AI.Context, AI.getType()->getElementType(),    
+  : AllocationInst(AI.getType()->getElementType(),    
                    (Value*)AI.getOperand(0), Instruction::Alloca,
                    AI.getAlignment()) {
 }
@@ -775,7 +771,7 @@ bool AllocaInst::isStaticAlloca() const {
 }
 
 MallocInst::MallocInst(const MallocInst &MI)
-  : AllocationInst(MI.Context, MI.getType()->getElementType(), 
+  : AllocationInst(MI.getType()->getElementType(), 
                    (Value*)MI.getOperand(0), Instruction::Malloc,
                    MI.getAlignment()) {
 }