Change the PointerType api for creating pointer types. The old functionality of PointerType::get() has become PointerType::getUnqual(), which returns a pointer in the generic address space. The new prototype of PointerType::get() requires both a type and an address space.

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

4 files changed, 39 insertions, 38 deletions

diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index f574ed4606..a858fb22fa 100644
--- a/lib/Transforms/IPO/GlobalOpt.cpp
+++ b/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1052,7 +1052,7 @@ static GlobalVariable *PerformHeapAllocSRoA(GlobalVariable *GV, MallocInst *MI){
   
   for (unsigned FieldNo = 0, e = STy->getNumElements(); FieldNo != e;++FieldNo){
     const Type *FieldTy = STy->getElementType(FieldNo);
-    const Type *PFieldTy = PointerType::get(FieldTy);
+    const Type *PFieldTy = PointerType::getUnqual(FieldTy);
     
     GlobalVariable *NGV =
       new GlobalVariable(PFieldTy, false, GlobalValue::InternalLinkage,
@@ -1618,7 +1618,7 @@ static GlobalVariable *InstallGlobalCtors(GlobalVariable *GCL,
     } else {
       const Type *FTy = FunctionType::get(Type::VoidTy,
                                           std::vector<const Type*>(), false);
-      const PointerType *PFTy = PointerType::get(FTy);
+      const PointerType *PFTy = PointerType::getUnqual(FTy);
       CSVals[1] = Constant::getNullValue(PFTy);
       CSVals[0] = ConstantInt::get(Type::Int32Ty, 2147483647);
     }
diff --git a/lib/Transforms/IPO/LowerSetJmp.cpp b/lib/Transforms/IPO/LowerSetJmp.cpp
index 90ece1799d..389ddebc6a 100644
--- a/lib/Transforms/IPO/LowerSetJmp.cpp
+++ b/lib/Transforms/IPO/LowerSetJmp.cpp
@@ -199,8 +199,8 @@ bool LowerSetJmp::runOnModule(Module& M) {
 // This function is always successful, unless it isn't.
 bool LowerSetJmp::doInitialization(Module& M)
 {
-  const Type *SBPTy = PointerType::get(Type::Int8Ty);
-  const Type *SBPPTy = PointerType::get(SBPTy);
+  const Type *SBPTy = PointerType::getUnqual(Type::Int8Ty);
+  const Type *SBPPTy = PointerType::getUnqual(SBPTy);
 
   // N.B. See llvm/runtime/GCCLibraries/libexception/SJLJ-Exception.h for
   // a description of the following library functions.
@@ -256,7 +256,7 @@ bool LowerSetJmp::IsTransformableFunction(const std::string& Name) {
 // throwing the exception for us.
 void LowerSetJmp::TransformLongJmpCall(CallInst* Inst)
 {
-  const Type* SBPTy = PointerType::get(Type::Int8Ty);
+  const Type* SBPTy = PointerType::getUnqual(Type::Int8Ty);
 
   // Create the call to "__llvm_sjljeh_throw_longjmp". This takes the
   // same parameters as "longjmp", except that the buffer is cast to a
@@ -308,7 +308,7 @@ AllocaInst* LowerSetJmp::GetSetJmpMap(Function* Func)
   assert(Inst && "Couldn't find even ONE instruction in entry block!");
 
   // Fill in the alloca and call to initialize the SJ map.
-  const Type *SBPTy = PointerType::get(Type::Int8Ty);
+  const Type *SBPTy = PointerType::getUnqual(Type::Int8Ty);
   AllocaInst* Map = new AllocaInst(SBPTy, 0, "SJMap", Inst);
   new CallInst(InitSJMap, Map, "", Inst);
   return SJMap[Func] = Map;
@@ -378,7 +378,7 @@ void LowerSetJmp::TransformSetJmpCall(CallInst* Inst)
   Function* Func = ABlock->getParent();
 
   // Add this setjmp to the setjmp map.
-  const Type* SBPTy = PointerType::get(Type::Int8Ty);
+  const Type* SBPTy = PointerType::getUnqual(Type::Int8Ty);
   CastInst* BufPtr = 
     new BitCastInst(Inst->getOperand(1), SBPTy, "SBJmpBuf", Inst);
   std::vector<Value*> Args = 
diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp
index e6d8723f45..ca4be9e528 100644
--- a/lib/Transforms/IPO/RaiseAllocations.cpp
+++ b/lib/Transforms/IPO/RaiseAllocations.cpp
@@ -78,7 +78,7 @@ void RaiseAllocations::doInitialization(Module &M) {
 
     // Get the expected prototype for malloc
     const FunctionType *Malloc1Type = 
-      FunctionType::get(PointerType::get(Type::Int8Ty),
+      FunctionType::get(PointerType::getUnqual(Type::Int8Ty),
                       std::vector<const Type*>(1, Type::Int64Ty), false);
 
     // Chck to see if we got the expected malloc
@@ -86,14 +86,14 @@ void RaiseAllocations::doInitialization(Module &M) {
       // Check to see if the prototype is wrong, giving us sbyte*(uint) * malloc
       // This handles the common declaration of: 'void *malloc(unsigned);'
       const FunctionType *Malloc2Type = 
-        FunctionType::get(PointerType::get(Type::Int8Ty),
+        FunctionType::get(PointerType::getUnqual(Type::Int8Ty),
                           std::vector<const Type*>(1, Type::Int32Ty), false);
       if (TyWeHave != Malloc2Type) {
         // Check to see if the prototype is missing, giving us 
         // sbyte*(...) * malloc
         // This handles the common declaration of: 'void *malloc();'
         const FunctionType *Malloc3Type = 
-          FunctionType::get(PointerType::get(Type::Int8Ty),
+          FunctionType::get(PointerType::getUnqual(Type::Int8Ty),
                             std::vector<const Type*>(), true);
         if (TyWeHave != Malloc3Type)
           // Give up
@@ -108,7 +108,7 @@ void RaiseAllocations::doInitialization(Module &M) {
     
     // Get the expected prototype for void free(i8*)
     const FunctionType *Free1Type = FunctionType::get(Type::VoidTy,
-        std::vector<const Type*>(1, PointerType::get(Type::Int8Ty)), false);
+      std::vector<const Type*>(1, PointerType::getUnqual(Type::Int8Ty)), false);
 
     if (TyWeHave != Free1Type) {
       // Check to see if the prototype was forgotten, giving us 
@@ -219,7 +219,8 @@ bool RaiseAllocations::runOnModule(Module &M) {
           //
           Value *Source = *CS.arg_begin();
           if (!isa<PointerType>(Source->getType()))
-            Source = new IntToPtrInst(Source, PointerType::get(Type::Int8Ty), 
+            Source = new IntToPtrInst(Source,           
+                                      PointerType::getUnqual(Type::Int8Ty), 
                                       "FreePtrCast", I);
           new FreeInst(Source, I);
 
diff --git a/lib/Transforms/IPO/SimplifyLibCalls.cpp b/lib/Transforms/IPO/SimplifyLibCalls.cpp
index 0904c4c6c1..1547b6c308 100644
--- a/lib/Transforms/IPO/SimplifyLibCalls.cpp
+++ b/lib/Transforms/IPO/SimplifyLibCalls.cpp
@@ -244,7 +244,7 @@ public:
   Constant *get_puts() {
     if (!puts_func)
       puts_func = M->getOrInsertFunction("puts", Type::Int32Ty,
-                                         PointerType::get(Type::Int8Ty),
+                                         PointerType::getUnqual(Type::Int8Ty),
                                          NULL);
     return puts_func;
   }
@@ -261,7 +261,7 @@ public:
   Constant *get_fputs(const Type* FILEptr_type) {
     if (!fputs_func)
       fputs_func = M->getOrInsertFunction("fputs", Type::Int32Ty,
-                                          PointerType::get(Type::Int8Ty),
+                                          PointerType::getUnqual(Type::Int8Ty),
                                           FILEptr_type, NULL);
     return fputs_func;
   }
@@ -270,7 +270,7 @@ public:
   Constant *get_fwrite(const Type* FILEptr_type) {
     if (!fwrite_func)
       fwrite_func = M->getOrInsertFunction("fwrite", TD->getIntPtrType(),
-                                           PointerType::get(Type::Int8Ty),
+                                           PointerType::getUnqual(Type::Int8Ty),
                                            TD->getIntPtrType(),
                                            TD->getIntPtrType(),
                                            FILEptr_type, NULL);
@@ -289,9 +289,9 @@ public:
   Constant *get_strcpy() {
     if (!strcpy_func)
       strcpy_func = M->getOrInsertFunction("strcpy",
-                                           PointerType::get(Type::Int8Ty),
-                                           PointerType::get(Type::Int8Ty),
-                                           PointerType::get(Type::Int8Ty),
+                                           PointerType::getUnqual(Type::Int8Ty),
+                                           PointerType::getUnqual(Type::Int8Ty),
+                                           PointerType::getUnqual(Type::Int8Ty),
                                            NULL);
     return strcpy_func;
   }
@@ -300,7 +300,7 @@ public:
   Constant *get_strlen() {
     if (!strlen_func)
       strlen_func = M->getOrInsertFunction("strlen", TD->getIntPtrType(),
-                                           PointerType::get(Type::Int8Ty),
+                                           PointerType::getUnqual(Type::Int8Ty),
                                            NULL);
     return strlen_func;
   }
@@ -309,8 +309,8 @@ public:
   Constant *get_memchr() {
     if (!memchr_func)
       memchr_func = M->getOrInsertFunction("memchr",
-                                           PointerType::get(Type::Int8Ty),
-                                           PointerType::get(Type::Int8Ty),
+                                           PointerType::getUnqual(Type::Int8Ty),
+                                           PointerType::getUnqual(Type::Int8Ty),
                                            Type::Int32Ty, TD->getIntPtrType(),
                                            NULL);
     return memchr_func;
@@ -319,7 +319,7 @@ public:
   /// @brief Return a Function* for the memcpy libcall
   Constant *get_memcpy() {
     if (!memcpy_func) {
-      const Type *SBP = PointerType::get(Type::Int8Ty);
+      const Type *SBP = PointerType::getUnqual(Type::Int8Ty);
       const char *N = TD->getIntPtrType() == Type::Int32Ty ?
                             "llvm.memcpy.i32" : "llvm.memcpy.i64";
       memcpy_func = M->getOrInsertFunction(N, Type::VoidTy, SBP, SBP,
@@ -471,7 +471,7 @@ public:
   virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
     const FunctionType *FT = F->getFunctionType();
     return FT->getNumParams() == 2 &&
-           FT->getReturnType() == PointerType::get(Type::Int8Ty) &&
+           FT->getReturnType() == PointerType::getUnqual(Type::Int8Ty) &&
            FT->getParamType(0) == FT->getReturnType() &&
            FT->getParamType(1) == FT->getReturnType();
   }
@@ -528,7 +528,7 @@ public:
   virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
     const FunctionType *FT = F->getFunctionType();
     return FT->getNumParams() == 2 &&
-           FT->getReturnType() == PointerType::get(Type::Int8Ty) &&
+           FT->getReturnType() == PointerType::getUnqual(Type::Int8Ty) &&
            FT->getParamType(0) == FT->getReturnType() &&
            isa<IntegerType>(FT->getParamType(1));
   }
@@ -594,7 +594,7 @@ public:
     const FunctionType *FT = F->getFunctionType();
     return FT->getReturnType() == Type::Int32Ty && FT->getNumParams() == 2 &&
            FT->getParamType(0) == FT->getParamType(1) &&
-           FT->getParamType(0) == PointerType::get(Type::Int8Ty);
+           FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty);
   }
 
   /// @brief Perform the strcmp optimization
@@ -647,7 +647,7 @@ public:
     const FunctionType *FT = F->getFunctionType();
     return FT->getReturnType() == Type::Int32Ty && FT->getNumParams() == 3 &&
            FT->getParamType(0) == FT->getParamType(1) &&
-           FT->getParamType(0) == PointerType::get(Type::Int8Ty) &&
+           FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty) &&
            isa<IntegerType>(FT->getParamType(2));
     return false;
   }
@@ -715,7 +715,7 @@ public:
     return FT->getNumParams() == 2 &&
            FT->getParamType(0) == FT->getParamType(1) &&
            FT->getReturnType() == FT->getParamType(0) &&
-           FT->getParamType(0) == PointerType::get(Type::Int8Ty);
+           FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty);
   }
 
   /// @brief Perform the strcpy optimization
@@ -770,7 +770,7 @@ struct VISIBILITY_HIDDEN StrLenOptimization : public LibCallOptimization {
   virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
     const FunctionType *FT = F->getFunctionType();
     return FT->getNumParams() == 1 &&
-           FT->getParamType(0) == PointerType::get(Type::Int8Ty) &&
+           FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty) &&
            isa<IntegerType>(FT->getReturnType());
   }
 
@@ -870,7 +870,7 @@ struct VISIBILITY_HIDDEN memcmpOptimization : public LibCallOptimization {
       return ReplaceCallWith(CI, Constant::getNullValue(CI->getType()));
     case 1: {
       // memcmp(S1,S2,1) -> *(ubyte*)S1 - *(ubyte*)S2
-      const Type *UCharPtr = PointerType::get(Type::Int8Ty);
+      const Type *UCharPtr = PointerType::getUnqual(Type::Int8Ty);
       CastInst *Op1Cast = CastInst::create(
           Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI);
       CastInst *Op2Cast = CastInst::create(
@@ -888,7 +888,7 @@ struct VISIBILITY_HIDDEN memcmpOptimization : public LibCallOptimization {
         // TODO: IF both are aligned, use a short load/compare.
       
         // memcmp(S1,S2,2) -> S1[0]-S2[0] | S1[1]-S2[1] iff only ==/!= 0 matters
-        const Type *UCharPtr = PointerType::get(Type::Int8Ty);
+        const Type *UCharPtr = PointerType::getUnqual(Type::Int8Ty);
         CastInst *Op1Cast = CastInst::create(
             Instruction::BitCast, LHS, UCharPtr, LHS->getName(), CI);
         CastInst *Op2Cast = CastInst::create(
@@ -976,9 +976,9 @@ struct VISIBILITY_HIDDEN LLVMMemCpyMoveOptzn : public LibCallOptimization {
 
     // Cast source and dest to the right sized primitive and then load/store
     CastInst* SrcCast = CastInst::create(Instruction::BitCast,
-        src, PointerType::get(castType), src->getName()+".cast", ci);
+        src, PointerType::getUnqual(castType), src->getName()+".cast", ci);
     CastInst* DestCast = CastInst::create(Instruction::BitCast,
-        dest, PointerType::get(castType),dest->getName()+".cast", ci);
+        dest, PointerType::getUnqual(castType),dest->getName()+".cast", ci);
     LoadInst* LI = new LoadInst(SrcCast,SrcCast->getName()+".val",ci);
     new StoreInst(LI, DestCast, ci);
     return ReplaceCallWith(ci, 0);
@@ -1085,7 +1085,7 @@ struct VISIBILITY_HIDDEN LLVMMemSetOptimization : public LibCallOptimization {
     }
 
     // Cast dest to the right sized primitive and then load/store
-    CastInst* DestCast = new BitCastInst(dest, PointerType::get(castType), 
+    CastInst* DestCast = new BitCastInst(dest, PointerType::getUnqual(castType), 
                                          dest->getName()+".cast", ci);
     new StoreInst(ConstantInt::get(castType,fill_value),DestCast, ci);
     return ReplaceCallWith(ci, 0);
@@ -1207,7 +1207,7 @@ public:
                                         Init, "str",
                                      CI->getParent()->getParent()->getParent());
       // Cast GV to be a pointer to char.
-      GV = ConstantExpr::getBitCast(GV, PointerType::get(Type::Int8Ty));
+      GV = ConstantExpr::getBitCast(GV, PointerType::getUnqual(Type::Int8Ty));
       new CallInst(SLC.get_puts(), GV, "", CI);
 
       if (CI->use_empty()) return ReplaceCallWith(CI, 0);
@@ -1268,7 +1268,7 @@ public:
   virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
     const FunctionType *FT = F->getFunctionType();
     return FT->getNumParams() == 2 &&  // two fixed arguments.
-           FT->getParamType(1) == PointerType::get(Type::Int8Ty) &&
+           FT->getParamType(1) == PointerType::getUnqual(Type::Int8Ty) &&
            isa<PointerType>(FT->getParamType(0)) &&
            isa<IntegerType>(FT->getReturnType());
   }
@@ -1358,7 +1358,7 @@ public:
   virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
     const FunctionType *FT = F->getFunctionType();
     return FT->getNumParams() == 2 &&  // two fixed arguments.
-           FT->getParamType(1) == PointerType::get(Type::Int8Ty) &&
+           FT->getParamType(1) == PointerType::getUnqual(Type::Int8Ty) &&
            FT->getParamType(0) == FT->getParamType(1) &&
            isa<IntegerType>(FT->getReturnType());
   }
@@ -1491,7 +1491,7 @@ public:
   virtual bool ValidateCalledFunction(const Function *F, SimplifyLibCalls &SLC){
     const FunctionType *FT = F->getFunctionType();
     return FT->getNumParams() == 4 && 
-           FT->getParamType(0) == PointerType::get(Type::Int8Ty) &&
+           FT->getParamType(0) == PointerType::getUnqual(Type::Int8Ty) &&
            FT->getParamType(1) == FT->getParamType(2) &&
            isa<IntegerType>(FT->getParamType(1)) &&
            isa<PointerType>(FT->getParamType(3)) &&
@@ -1927,7 +1927,7 @@ static bool GetConstantStringInfo(Value *V, std::string &Str) {
 static Value *CastToCStr(Value *V, Instruction *IP) {
   assert(isa<PointerType>(V->getType()) && 
          "Can't cast non-pointer type to C string type");
-  const Type *SBPTy = PointerType::get(Type::Int8Ty);
+  const Type *SBPTy = PointerType::getUnqual(Type::Int8Ty);
   if (V->getType() != SBPTy)
     return new BitCastInst(V, SBPTy, V->getName(), IP);
   return V;