Change the PointerType api for creating pointer types. The old functionality of Point...

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

diff --git a/examples/BrainF/BrainF.cpp b/examples/BrainF/BrainF.cpp
index e7e11aca0b11baa2f7c0d18f7e80cdc6e038cef7..b75b51943c24525ef1db1d40d3ec9394a66bea8e 100644 (file)
--- a/examples/BrainF/BrainF.cpp
+++ b/examples/BrainF/BrainF.cpp
@@ -54,7 +54,7 @@ void BrainF::header() {
   //declare void @llvm.memset.i32(i8 *, i8, i32, i32)
   Function *memset_func = cast<Function>(module->
     getOrInsertFunction("llvm.memset.i32", Type::VoidTy,
-                        PointerType::get(IntegerType::Int8Ty),
+                        PointerType::getUnqual(IntegerType::Int8Ty),
                         IntegerType::Int8Ty, IntegerType::Int32Ty,
                         IntegerType::Int32Ty, NULL));
 
@@ -138,7 +138,7 @@ void BrainF::header() {
     //declare i32 @puts(i8 *)
     Function *puts_func = cast<Function>(module->
       getOrInsertFunction("puts", IntegerType::Int32Ty,
-                          PointerType::get(IntegerType::Int8Ty), NULL));
+                          PointerType::getUnqual(IntegerType::Int8Ty), NULL));
 
     //brainf.aberror:
     aberrorbb = new BasicBlock(label, brainf_func);
@@ -282,7 +282,7 @@ void BrainF::readloop(PHINode *phi, BasicBlock *oldbb, BasicBlock *testbb) {
           builder->SetInsertPoint(bb_1);
 
           //Make part of PHI instruction now, wait until end of loop to finish
-          PHINode *phi_0 = new PHINode(PointerType::get(IntegerType::Int8Ty),
+          PHINode *phi_0 = new PHINode(PointerType::getUnqual(IntegerType::Int8Ty),
                                        headreg, testbb);
           phi_0->reserveOperandSpace(2);
           phi_0->addIncoming(curhead, bb_0);
@@ -439,7 +439,7 @@ void BrainF::readloop(PHINode *phi, BasicBlock *oldbb, BasicBlock *testbb) {
 
       //%head.%d = phi i8 *[%head.%d, %main.%d]
       PHINode *phi_1 = builder->
-        CreatePHI(PointerType::get(IntegerType::Int8Ty), headreg);
+        CreatePHI(PointerType::getUnqual(IntegerType::Int8Ty), headreg);
       phi_1->reserveOperandSpace(1);
       phi_1->addIncoming(head_0, testbb);
       curhead = phi_1;

diff --git a/examples/BrainF/BrainFDriver.cpp b/examples/BrainF/BrainFDriver.cpp
index 7d29fe6f72f790cacf07029580e157f7e50d8cbb..3f3b6c339280d25dca3f7344f1b59d9e4ca16d7e 100644 (file)
--- a/examples/BrainF/BrainFDriver.cpp
+++ b/examples/BrainF/BrainFDriver.cpp
@@ -59,7 +59,7 @@ void addMainFunction(Module *mod) {
   //define i32 @main(i32 %argc, i8 **%argv)
   Function *main_func = cast<Function>(mod->
     getOrInsertFunction("main", IntegerType::Int32Ty, IntegerType::Int32Ty,
-                        PointerType::get(PointerType::get(
+                        PointerType::getUnqual(PointerType::getUnqual(
                           IntegerType::Int8Ty)), NULL));
   {
     Function::arg_iterator args = main_func->arg_begin();

diff --git a/include/llvm/DerivedTypes.h b/include/llvm/DerivedTypes.h
index d62cb3bcc959aa95733550fcffdfa6c755e5e6c4..c294f402e686078cb1e231bef34219bef70074fc 100644 (file)
--- a/include/llvm/DerivedTypes.h
+++ b/include/llvm/DerivedTypes.h
@@ -369,8 +369,15 @@ class PointerType : public SequentialType {
   const PointerType &operator=(const PointerType &);  // Do not implement
   explicit PointerType(const Type *ElType, unsigned AddrSpace);
 public:
-  /// PointerType::get - This is the only way to construct a new pointer type.
-  static PointerType *get(const Type *ElementType, unsigned AddressSpace = 0);
+  /// PointerType::get - This constructs a pointer to an object of the specified 
+  /// type in a numbered address space.
+  static PointerType *get(const Type *ElementType, unsigned AddressSpace);
+  
+  /// PointerType::getUnqual - This constructs a pointer to an object of the  
+  /// specified type in the generic address space (address space zero).
+  static PointerType *getUnqual(const Type *ElementType) { 
+    return PointerType::get(ElementType, 0);
+  }
   
   /// @brief Return the address space of the Pointer type.
   inline unsigned getAddressSpace() const { return AddressSpace; }

diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index c1f52a2eb0371a7d637341ca8e2e5f07febae82a..855034cd92d16f18f6b20c76b62dec421f24062a 100644 (file)
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -2280,7 +2280,7 @@ FunctionHeaderH : OptCallingConv ResultTypes GlobalName '(' ArgList ')'
     PAL = ParamAttrsList::get(Attrs);
 
   FunctionType *FT = FunctionType::get(*$2, ParamTypeList, isVarArg);
-  const PointerType *PFT = PointerType::get(FT);
+  const PointerType *PFT = PointerType::getUnqual(FT);
   delete $2;
 
   ValID ID;
@@ -2627,7 +2627,7 @@ BBTerminatorInst : RET ResolvedVal {              // Return with a result...
         ParamTypes.push_back(Ty);
       }
       Ty = FunctionType::get($3->get(), ParamTypes, false);
-      PFTy = PointerType::get(Ty);
+      PFTy = PointerType::getUnqual(Ty);
     }
 
     delete $3;
@@ -2954,7 +2954,7 @@ InstVal : ArithmeticOps Types ValueRef ',' ValueRef {
         ParamTypes.push_back(Ty);
       }
       Ty = FunctionType::get($3->get(), ParamTypes, false);
-      PFTy = PointerType::get(Ty);
+      PFTy = PointerType::getUnqual(Ty);
     }
 
     Value *V = getVal(PFTy, $4);   // Get the function we're calling...

diff --git a/lib/Bitcode/Reader/BitcodeReader.cpp b/lib/Bitcode/Reader/BitcodeReader.cpp
index 72756ef6cd6f5e1d9beb2d61ec6eb27a6dbea094..4e761e402b854668da8cfdfff2a7d08743d60158 100644 (file)
--- a/lib/Bitcode/Reader/BitcodeReader.cpp
+++ b/lib/Bitcode/Reader/BitcodeReader.cpp
@@ -1509,7 +1509,7 @@ bool BitcodeReader::ParseFunctionBody(Function *F) {
       unsigned OpNum = 0;
       Value *Val, *Ptr;
       if (getValueTypePair(Record, OpNum, NextValueNo, Val) ||
-          getValue(Record, OpNum, PointerType::get(Val->getType()), Ptr) ||
+          getValue(Record, OpNum, PointerType::getUnqual(Val->getType()), Ptr)||
           OpNum+2 != Record.size())
         return Error("Invalid STORE record");
       

diff --git a/lib/CodeGen/IntrinsicLowering.cpp b/lib/CodeGen/IntrinsicLowering.cpp
index 0d1da867ed0d339ff921dbfbe1a931cbf2181439..ef14f0b322f285f065f8216c86b47af64e6ef07e 100644 (file)
--- a/lib/CodeGen/IntrinsicLowering.cpp
+++ b/lib/CodeGen/IntrinsicLowering.cpp
@@ -81,22 +81,23 @@ void IntrinsicLowering::AddPrototypes(Module &M) {
         break;
       case Intrinsic::memcpy_i32:
       case Intrinsic::memcpy_i64:
-        M.getOrInsertFunction("memcpy", PointerType::get(Type::Int8Ty),
-                              PointerType::get(Type::Int8Ty), 
-                              PointerType::get(Type::Int8Ty), 
+        M.getOrInsertFunction("memcpy", PointerType::getUnqual(Type::Int8Ty),
+                              PointerType::getUnqual(Type::Int8Ty), 
+                              PointerType::getUnqual(Type::Int8Ty), 
                               TD.getIntPtrType(), (Type *)0);
         break;
       case Intrinsic::memmove_i32:
       case Intrinsic::memmove_i64:
-        M.getOrInsertFunction("memmove", PointerType::get(Type::Int8Ty),
-                              PointerType::get(Type::Int8Ty), 
-                              PointerType::get(Type::Int8Ty), 
+        M.getOrInsertFunction("memmove", PointerType::getUnqual(Type::Int8Ty),
+                              PointerType::getUnqual(Type::Int8Ty), 
+                              PointerType::getUnqual(Type::Int8Ty), 
                               TD.getIntPtrType(), (Type *)0);
         break;
       case Intrinsic::memset_i32:
       case Intrinsic::memset_i64:
-        M.getOrInsertFunction("memset", PointerType::get(Type::Int8Ty),
-                              PointerType::get(Type::Int8Ty), Type::Int32Ty, 
+        M.getOrInsertFunction("memset", PointerType::getUnqual(Type::Int8Ty),
+                              PointerType::getUnqual(Type::Int8Ty), 
+                              Type::Int32Ty, 
                               TD.getIntPtrType(), (Type *)0);
         break;
       case Intrinsic::sqrt:

diff --git a/lib/CodeGen/MachineModuleInfo.cpp b/lib/CodeGen/MachineModuleInfo.cpp
index 9943fa9967693d7f7a4e22294c1cdc958a5b1b9f..14253f41117be5e248163336bc7b18cf4dd2c608 100644 (file)
--- a/lib/CodeGen/MachineModuleInfo.cpp
+++ b/lib/CodeGen/MachineModuleInfo.cpp
@@ -1262,7 +1262,7 @@ const PointerType *DISerializer::getStrPtrType() {
   // If not already defined.
   if (!StrPtrTy) {
     // Construct the pointer to signed bytes.
-    StrPtrTy = PointerType::get(Type::Int8Ty);
+    StrPtrTy = PointerType::getUnqual(Type::Int8Ty);
   }
   
   return StrPtrTy;
@@ -1277,7 +1277,7 @@ const PointerType *DISerializer::getEmptyStructPtrType() {
     const StructType *EmptyStructTy =
                                     StructType::get(std::vector<const Type*>());
     // Construct the pointer to empty structure type.
-    EmptyStructPtrTy = PointerType::get(EmptyStructTy);
+    EmptyStructPtrTy = PointerType::getUnqual(EmptyStructTy);
   }
   
   return EmptyStructPtrTy;

diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp
index 83c0094a493365ae7d5d27b83ca449e250ffe0e6..6c2d9c384194d0a7b034b63b8ff5b91106f8ac3f 100644 (file)
--- a/lib/ExecutionEngine/ExecutionEngine.cpp
+++ b/lib/ExecutionEngine/ExecutionEngine.cpp
@@ -170,7 +170,7 @@ static void *CreateArgv(ExecutionEngine *EE,
   char *Result = new char[(InputArgv.size()+1)*PtrSize];
 
   DOUT << "ARGV = " << (void*)Result << "\n";
-  const Type *SBytePtr = PointerType::get(Type::Int8Ty);
+  const Type *SBytePtr = PointerType::getUnqual(Type::Int8Ty);
 
   for (unsigned i = 0; i != InputArgv.size(); ++i) {
     unsigned Size = InputArgv[i].size()+1;
@@ -255,7 +255,8 @@ int ExecutionEngine::runFunctionAsMain(Function *Fn,
   // Check main() type
   unsigned NumArgs = Fn->getFunctionType()->getNumParams();
   const FunctionType *FTy = Fn->getFunctionType();
-  const Type* PPInt8Ty = PointerType::get(PointerType::get(Type::Int8Ty));
+  const Type* PPInt8Ty = 
+    PointerType::getUnqual(PointerType::getUnqual(Type::Int8Ty));
   switch (NumArgs) {
   case 3:
    if (FTy->getParamType(2) != PPInt8Ty) {

diff --git a/lib/Target/MSIL/MSILWriter.cpp b/lib/Target/MSIL/MSILWriter.cpp
index 87107d8908dbdb916270be6fbbc8eb62a6bc9791..cc4739a8b0c2522c2b55a561b624a21e720e46aa 100644 (file)
--- a/lib/Target/MSIL/MSILWriter.cpp
+++ b/lib/Target/MSIL/MSILWriter.cpp
@@ -783,7 +783,7 @@ void MSILWriter::printIntrinsicCall(const IntrinsicInst* Inst) {
     // Save as pointer type "void*"
     printValueLoad(Inst->getOperand(1));
     printSimpleInstruction("ldloca",Name.c_str());
-    printIndirectSave(PointerType::get(IntegerType::get(8)));
+    printIndirectSave(PointerType::getUnqual(IntegerType::get(8)));
     break;
   case Intrinsic::vaend:
     // Close argument list handle.
@@ -1002,7 +1002,8 @@ void MSILWriter::printVAArgInstruction(const VAArgInst* Inst) {
   printSimpleInstruction("call",
     "instance typedref [mscorlib]System.ArgIterator::GetNextArg()");
   printSimpleInstruction("refanyval","void*");
-  std::string Name = "ldind."+getTypePostfix(PointerType::get(IntegerType::get(8)),false);
+  std::string Name = 
+    "ldind."+getTypePostfix(PointerType::getUnqual(IntegerType::get(8)),false);
   printSimpleInstruction(Name.c_str());
 }
 
@@ -1217,7 +1218,7 @@ void MSILWriter::printLocalVariables(const Function& F) {
     const AllocaInst* AI = dyn_cast<AllocaInst>(&*I);
     if (AI && !isa<GlobalVariable>(AI)) {
       // Local variable allocation.
-      Ty = PointerType::get(AI->getAllocatedType());
+      Ty = PointerType::getUnqual(AI->getAllocatedType());
       Name = getValueName(AI);
       Out << "\t.locals (" << getTypeName(Ty) << Name << ")\n";
     } else if (I->getType()!=Type::VoidTy) {

diff --git a/lib/Transforms/IPO/GlobalOpt.cpp b/lib/Transforms/IPO/GlobalOpt.cpp
index f574ed4606381eb67cdea96dc66d5a2202dbfdba..a858fb22fa9c5d3dea50208c89f0b016631ad3fc 100644 (file)
--- 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 90ece1799da797df760861ea574dcb1f90b96f07..389ddebc6a0fc52166490b751375980f09f0e3a8 100644 (file)
--- 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 e6d8723f457b3d2df2994af749d616df9b8a1ae1..ca4be9e528bebebc2b3c4e720f259b0d0ace0c97 100644 (file)
--- 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 0904c4c6c19e779bb5bdd18403cc7f20cb22cb17..1547b6c308ec40985e74b13876c4720b5af96784 100644 (file)
--- 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;

diff --git a/lib/Transforms/Instrumentation/ProfilingUtils.cpp b/lib/Transforms/Instrumentation/ProfilingUtils.cpp
index 91b8ec2c5c935c14e257a3cc18b997e76d2cc3c2..dacd92aef769ef47ed11622c1f0aefa31241485b 100644 (file)
--- a/lib/Transforms/Instrumentation/ProfilingUtils.cpp
+++ b/lib/Transforms/Instrumentation/ProfilingUtils.cpp
@@ -22,8 +22,9 @@
 
 void llvm::InsertProfilingInitCall(Function *MainFn, const char *FnName,
                                    GlobalValue *Array) {
-  const Type *ArgVTy = PointerType::get(PointerType::get(Type::Int8Ty));
-  const PointerType *UIntPtr = PointerType::get(Type::Int32Ty);
+  const Type *ArgVTy = 
+    PointerType::getUnqual(PointerType::getUnqual(Type::Int8Ty));
+  const PointerType *UIntPtr = PointerType::getUnqual(Type::Int32Ty);
   Module &M = *MainFn->getParent();
   Constant *InitFn = M.getOrInsertFunction(FnName, Type::Int32Ty, Type::Int32Ty,
                                            ArgVTy, UIntPtr, Type::Int32Ty,

diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index aa9e932fc527379c732c9d203e59c280093e6799..7989ebf1979639d4bedd8ddc793d04bf7fb60bd4 100644 (file)
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -2122,8 +2122,10 @@ Instruction *InstCombiner::visitAdd(BinaryOperator &I) {
         (CI->getType()->getPrimitiveSizeInBits() == 
          TD->getIntPtrType()->getPrimitiveSizeInBits()) 
         && isa<PointerType>(CI->getOperand(0)->getType())) {
+      unsigned AS =
+        cast<PointerType>(CI->getOperand(0)->getType())->getAddressSpace();
       Value *I2 = InsertCastBefore(Instruction::BitCast, CI->getOperand(0),
-                                   PointerType::get(Type::Int8Ty), I);
+                                   PointerType::get(Type::Int8Ty, AS), I);
       I2 = InsertNewInstBefore(new GetElementPtrInst(I2, Other, "ctg2"), I);
       return new PtrToIntInst(I2, CI->getType());
     }
@@ -7740,7 +7742,7 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
         // If Size is 2 then use Int16Ty
         // If Size is 1 then use Int8Ty
         if (Size && Size <=8 && !(Size&(Size-1)))
-          NewPtrTy = PointerType::get(IntegerType::get(Size<<3));
+          NewPtrTy = PointerType::getUnqual(IntegerType::get(Size<<3));
 
         if (NewPtrTy) {
           Value *Src = InsertCastBefore(Instruction::BitCast, CI.getOperand(2),
@@ -7774,8 +7776,9 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
       // Turn PPC lvx     -> load if the pointer is known aligned.
       // Turn X86 loadups -> load if the pointer is known aligned.
       if (GetOrEnforceKnownAlignment(II->getOperand(1), TD, 16) >= 16) {
-        Value *Ptr = InsertCastBefore(Instruction::BitCast, II->getOperand(1),
-                                      PointerType::get(II->getType()), CI);
+        Value *Ptr = 
+          InsertCastBefore(Instruction::BitCast, II->getOperand(1),
+                           PointerType::getUnqual(II->getType()), CI);
         return new LoadInst(Ptr);
       }
       break;
@@ -7783,7 +7786,8 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
     case Intrinsic::ppc_altivec_stvxl:
       // Turn stvx -> store if the pointer is known aligned.
       if (GetOrEnforceKnownAlignment(II->getOperand(2), TD, 16) >= 16) {
-        const Type *OpPtrTy = PointerType::get(II->getOperand(1)->getType());
+        const Type *OpPtrTy = 
+          PointerType::getUnqual(II->getOperand(1)->getType());
         Value *Ptr = InsertCastBefore(Instruction::BitCast, II->getOperand(2),
                                       OpPtrTy, CI);
         return new StoreInst(II->getOperand(1), Ptr);
@@ -7795,7 +7799,8 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
     case Intrinsic::x86_sse2_storel_dq:
       // Turn X86 storeu -> store if the pointer is known aligned.
       if (GetOrEnforceKnownAlignment(II->getOperand(1), TD, 16) >= 16) {
-        const Type *OpPtrTy = PointerType::get(II->getOperand(2)->getType());
+        const Type *OpPtrTy = 
+          PointerType::getUnqual(II->getOperand(2)->getType());
         Value *Ptr = InsertCastBefore(Instruction::BitCast, II->getOperand(1),
                                       OpPtrTy, CI);
         return new StoreInst(II->getOperand(2), Ptr);
@@ -7921,7 +7926,8 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) {
       // If the call and callee calling conventions don't match, this call must
       // be unreachable, as the call is undefined.
       new StoreInst(ConstantInt::getTrue(),
-                    UndefValue::get(PointerType::get(Type::Int1Ty)), OldCall);
+                    UndefValue::get(PointerType::getUnqual(Type::Int1Ty)), 
+                                    OldCall);
       if (!OldCall->use_empty())
         OldCall->replaceAllUsesWith(UndefValue::get(OldCall->getType()));
       if (isa<CallInst>(OldCall))   // Not worth removing an invoke here.
@@ -7934,7 +7940,7 @@ Instruction *InstCombiner::visitCallSite(CallSite CS) {
     // undef so that we know that this code is not reachable, despite the fact
     // that we can't modify the CFG here.
     new StoreInst(ConstantInt::getTrue(),
-                  UndefValue::get(PointerType::get(Type::Int1Ty)),
+                  UndefValue::get(PointerType::getUnqual(Type::Int1Ty)),
                   CS.getInstruction());
 
     if (!CS.getInstruction()->use_empty())
@@ -8299,8 +8305,8 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) {
       // code sort out any function type mismatches.
       FunctionType *NewFTy =
         FunctionType::get(FTy->getReturnType(), NewTypes, FTy->isVarArg());
-      Constant *NewCallee = NestF->getType() == PointerType::get(NewFTy) ?
-        NestF : ConstantExpr::getBitCast(NestF, PointerType::get(NewFTy));
+      Constant *NewCallee = NestF->getType() == PointerType::getUnqual(NewFTy) ?
+        NestF : ConstantExpr::getBitCast(NestF, PointerType::getUnqual(NewFTy));
       const ParamAttrsList *NewPAL = ParamAttrsList::get(NewAttrs);
 
       Instruction *NewCaller;
@@ -9052,7 +9058,7 @@ Instruction *InstCombiner::visitFreeInst(FreeInst &FI) {
   if (isa<UndefValue>(Op)) {
     // Insert a new store to null because we cannot modify the CFG here.
     new StoreInst(ConstantInt::getTrue(),
-                  UndefValue::get(PointerType::get(Type::Int1Ty)), &FI);
+                  UndefValue::get(PointerType::getUnqual(Type::Int1Ty)), &FI);
     return EraseInstFromFunction(FI);
   }
   
@@ -9887,8 +9893,10 @@ Instruction *InstCombiner::visitExtractElementInst(ExtractElementInst &EI) {
           return BinaryOperator::create(BO->getOpcode(), newEI0, newEI1);
         }
       } else if (isa<LoadInst>(I)) {
+        unsigned AS = 
+          cast<PointerType>(I->getOperand(0)->getType())->getAddressSpace();
         Value *Ptr = InsertCastBefore(Instruction::BitCast, I->getOperand(0),
-                                      PointerType::get(EI.getType()), EI);
+                                      PointerType::get(EI.getType(), AS), EI);
         GetElementPtrInst *GEP = 
           new GetElementPtrInst(Ptr, EI.getOperand(1), I->getName() + ".gep");
         InsertNewInstBefore(GEP, EI);

diff --git a/lib/Transforms/Scalar/LowerGC.cpp b/lib/Transforms/Scalar/LowerGC.cpp
index 9935a84cda8fcd85f13709ff14e527ee1dfd9fc7..e7a9997bc1f733df1ea63bd1a272cc7471b9bebd 100644 (file)
--- a/lib/Transforms/Scalar/LowerGC.cpp
+++ b/lib/Transforms/Scalar/LowerGC.cpp
@@ -86,7 +86,7 @@ const StructType *LowerGC::getRootRecordType(unsigned NumRoots) {
   PATypeHolder RootListH =
     MainRootRecordType ? (Type*)MainRootRecordType : (Type*)OpaqueType::get();
   ST.clear();
-  ST.push_back(PointerType::get(RootListH));         // Prev pointer
+  ST.push_back(PointerType::getUnqual(RootListH));         // Prev pointer
   ST.push_back(Type::Int32Ty);                       // NumElements in array
   ST.push_back(PairArrTy);                           // The pairs
   StructType *RootList = StructType::get(ST);
@@ -107,8 +107,8 @@ bool LowerGC::doInitialization(Module &M) {
   GCWriteInt = M.getFunction("llvm.gcwrite");
   if (!GCRootInt && !GCReadInt && !GCWriteInt) return false;
 
-  PointerType *VoidPtr = PointerType::get(Type::Int8Ty);
-  PointerType *VoidPtrPtr = PointerType::get(VoidPtr);
+  PointerType *VoidPtr = PointerType::getUnqual(Type::Int8Ty);
+  PointerType *VoidPtrPtr = PointerType::getUnqual(VoidPtr);
 
   // If the program is using read/write barriers, find the implementations of
   // them from the GC runtime library.
@@ -122,7 +122,7 @@ bool LowerGC::doInitialization(Module &M) {
   // If the program has GC roots, get or create the global root list.
   if (GCRootInt) {
     const StructType *RootListTy = getRootRecordType(0);
-    const Type *PRLTy = PointerType::get(RootListTy);
+    const Type *PRLTy = PointerType::getUnqual(RootListTy);
     M.addTypeName("llvm_gc_root_ty", RootListTy);
 
     // Get the root chain if it already exists.
@@ -163,8 +163,8 @@ bool LowerGC::runOnFunction(Function &F) {
   // Quick exit for programs that are not using GC mechanisms.
   if (!GCRootInt && !GCReadInt && !GCWriteInt) return false;
 
-  PointerType *VoidPtr    = PointerType::get(Type::Int8Ty);
-  PointerType *VoidPtrPtr = PointerType::get(VoidPtr);
+  PointerType *VoidPtr    = PointerType::getUnqual(Type::Int8Ty);
+  PointerType *VoidPtrPtr = PointerType::getUnqual(VoidPtr);
 
   // If there are read/write barriers in the program, perform a quick pass over
   // the function eliminating them.  While we are at it, remember where we see
@@ -290,7 +290,7 @@ bool LowerGC::runOnFunction(Function &F) {
 
   // Now that the record is all initialized, store the pointer into the global
   // pointer.
-  Value *C = new BitCastInst(AI, PointerType::get(MainRootRecordType), "", IP);
+  Value *C = new BitCastInst(AI, PointerType::getUnqual(MainRootRecordType), "", IP);
   new StoreInst(C, RootChain, IP);
 
   // Eliminate all the gcroot records now.

diff --git a/lib/Transforms/Utils/CodeExtractor.cpp b/lib/Transforms/Utils/CodeExtractor.cpp
index c42d5e177d397e61b259da87c771da2d3164cc69..98b3f2b94014aa1ff21583c4834b098cd2e6efbe 100644 (file)
--- a/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/lib/Transforms/Utils/CodeExtractor.cpp
@@ -263,7 +263,7 @@ Function *CodeExtractor::constructFunction(const Values &inputs,
     if (AggregateArgs)
       paramTy.push_back((*I)->getType());
     else
-      paramTy.push_back(PointerType::get((*I)->getType()));
+      paramTy.push_back(PointerType::getUnqual((*I)->getType()));
   }
 
   DOUT << "Function type: " << *RetTy << " f(";
@@ -273,7 +273,7 @@ Function *CodeExtractor::constructFunction(const Values &inputs,
   DOUT << ")\n";
 
   if (AggregateArgs && (inputs.size() + outputs.size() > 0)) {
-    PointerType *StructPtr = PointerType::get(StructType::get(paramTy));
+    PointerType *StructPtr = PointerType::getUnqual(StructType::get(paramTy));
     paramTy.clear();
     paramTy.push_back(StructPtr);
   }

diff --git a/lib/Transforms/Utils/InlineFunction.cpp b/lib/Transforms/Utils/InlineFunction.cpp
index e9f6b28e98b5259853d784452e9e069aba702c43..e88eb94282686320234c2d9139a8371a1f6ce8b4 100644 (file)
--- a/lib/Transforms/Utils/InlineFunction.cpp
+++ b/lib/Transforms/Utils/InlineFunction.cpp
@@ -277,7 +277,7 @@ bool llvm::InlineFunction(CallSite CS, CallGraph *CG, const TargetData *TD) {
   // code with llvm.stacksave/llvm.stackrestore intrinsics.
   if (InlinedFunctionInfo.ContainsDynamicAllocas) {
     Module *M = Caller->getParent();
-    const Type *BytePtr = PointerType::get(Type::Int8Ty);
+    const Type *BytePtr = PointerType::getUnqual(Type::Int8Ty);
     // Get the two intrinsics we care about.
     Constant *StackSave, *StackRestore;
     StackSave    = M->getOrInsertFunction("llvm.stacksave", BytePtr, NULL);

diff --git a/lib/Transforms/Utils/LowerAllocations.cpp b/lib/Transforms/Utils/LowerAllocations.cpp
index b089cd6d8b4fed8edbd14cead27a5453b63aa5d5..c5c8bd50da871d7edc28717123fbed61ff8dd88f 100644 (file)
--- a/lib/Transforms/Utils/LowerAllocations.cpp
+++ b/lib/Transforms/Utils/LowerAllocations.cpp
@@ -87,7 +87,7 @@ Pass *llvm::createLowerAllocationsPass(bool LowerMallocArgToInteger) {
 // This function is always successful.
 //
 bool LowerAllocations::doInitialization(Module &M) {
-  const Type *BPTy = PointerType::get(Type::Int8Ty);
+  const Type *BPTy = PointerType::getUnqual(Type::Int8Ty);
   // Prototype malloc as "char* malloc(...)", because we don't know in
   // doInitialization whether size_t is int or long.
   FunctionType *FT = FunctionType::get(BPTy, std::vector<const Type*>(), true);
@@ -158,8 +158,9 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) {
       Changed = true;
       ++NumLowered;
     } else if (FreeInst *FI = dyn_cast<FreeInst>(I)) {
-      Value *PtrCast = new BitCastInst(FI->getOperand(0),
-                                       PointerType::get(Type::Int8Ty), "", I);
+      Value *PtrCast = 
+        new BitCastInst(FI->getOperand(0),
+                        PointerType::getUnqual(Type::Int8Ty), "", I);
 
       // Insert a call to the free function...
       (new CallInst(FreeFunc, PtrCast, "", I))->setTailCall();

diff --git a/lib/Transforms/Utils/LowerInvoke.cpp b/lib/Transforms/Utils/LowerInvoke.cpp
index 24b167ac877632cce12f07211ecaf7561efff007..db49b780fd9d55cd37a4667ac5f3b78c06e338b2 100644 (file)
--- a/lib/Transforms/Utils/LowerInvoke.cpp
+++ b/lib/Transforms/Utils/LowerInvoke.cpp
@@ -114,7 +114,7 @@ FunctionPass *llvm::createLowerInvokePass(const TargetLowering *TLI) {
 // doInitialization - Make sure that there is a prototype for abort in the
 // current module.
 bool LowerInvoke::doInitialization(Module &M) {
-  const Type *VoidPtrTy = PointerType::get(Type::Int8Ty);
+  const Type *VoidPtrTy = PointerType::getUnqual(Type::Int8Ty);
   AbortMessage = 0;
   if (ExpensiveEHSupport) {
     // Insert a type for the linked list of jump buffers.
@@ -126,14 +126,14 @@ bool LowerInvoke::doInitialization(Module &M) {
       std::vector<const Type*> Elements;
       Elements.push_back(JmpBufTy);
       OpaqueType *OT = OpaqueType::get();
-      Elements.push_back(PointerType::get(OT));
+      Elements.push_back(PointerType::getUnqual(OT));
       PATypeHolder JBLType(StructType::get(Elements));
       OT->refineAbstractTypeTo(JBLType.get());  // Complete the cycle.
       JBLinkTy = JBLType.get();
       M.addTypeName("llvm.sjljeh.jmpbufty", JBLinkTy);
     }
 
-    const Type *PtrJBList = PointerType::get(JBLinkTy);
+    const Type *PtrJBList = PointerType::getUnqual(JBLinkTy);
 
     // Now that we've done that, insert the jmpbuf list head global, unless it
     // already exists.
@@ -144,9 +144,10 @@ bool LowerInvoke::doInitialization(Module &M) {
                                       "llvm.sjljeh.jblist", &M);
     }
     SetJmpFn = M.getOrInsertFunction("llvm.setjmp", Type::Int32Ty,
-                                     PointerType::get(JmpBufTy), (Type *)0);
+                                     PointerType::getUnqual(JmpBufTy), 
+                                     (Type *)0);
     LongJmpFn = M.getOrInsertFunction("llvm.longjmp", Type::VoidTy,
-                                      PointerType::get(JmpBufTy),
+                                      PointerType::getUnqual(JmpBufTy),
                                       Type::Int32Ty, (Type *)0);
   }
 

diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp
index a99ae9ded8a9416cb80bd102b1e5d158f8a90129..20e04cae4fb5aaa927c6f7200020c0e063e5dd19 100644 (file)
--- a/lib/VMCore/ConstantFold.cpp
+++ b/lib/VMCore/ConstantFold.cpp
@@ -1383,12 +1383,13 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
     return const_cast<Constant*>(C);
 
   if (isa<UndefValue>(C)) {
-    const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(),
+    const PointerType *Ptr = cast<PointerType>(C->getType());
+    const Type *Ty = GetElementPtrInst::getIndexedType(Ptr,
                                                        (Value **)Idxs,
                                                        (Value **)Idxs+NumIdx,
                                                        true);
     assert(Ty != 0 && "Invalid indices for GEP!");
-    return UndefValue::get(PointerType::get(Ty));
+    return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace()));
   }
 
   Constant *Idx0 = Idxs[0];
@@ -1400,12 +1401,14 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C,
         break;
       }
     if (isNull) {
-      const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(),
+      const PointerType *Ptr = cast<PointerType>(C->getType());
+      const Type *Ty = GetElementPtrInst::getIndexedType(Ptr,
                                                          (Value**)Idxs,
                                                          (Value**)Idxs+NumIdx,
                                                          true);
       assert(Ty != 0 && "Invalid indices for GEP!");
-      return ConstantPointerNull::get(PointerType::get(Ty));
+      return 
+        ConstantPointerNull::get(PointerType::get(Ty,Ptr->getAddressSpace()));
     }
   }
 

diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 964d8880e87b625d3cc67a2a30a0c5ac9e375033..83070c00e14af67d6cb412850da0a6921d5e045c 100644 (file)
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -1710,7 +1710,7 @@ Constant *ConstantExpr::getSizeOf(const Type *Ty) {
   // sizeof is implemented as: (i64) gep (Ty*)null, 1
   Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1);
   Constant *GEP =
-    getGetElementPtr(getNullValue(PointerType::get(Ty)), &GEPIdx, 1);
+    getGetElementPtr(getNullValue(PointerType::getUnqual(Ty)), &GEPIdx, 1);
   return getCast(Instruction::PtrToInt, GEP, Type::Int64Ty);
 }
 

diff --git a/lib/VMCore/Core.cpp b/lib/VMCore/Core.cpp
index b910cf1501160e6f158d34b2d7fff36fe02da090..9a7c7909e8176392fb6273863409193ef6bf4fbe 100644 (file)
--- a/lib/VMCore/Core.cpp
+++ b/lib/VMCore/Core.cpp
@@ -150,7 +150,8 @@ LLVMTypeRef LLVMArrayType(LLVMTypeRef ElementType, unsigned ElementCount){
 }
 
 LLVMTypeRef LLVMPointerType(LLVMTypeRef ElementType) {
-  return wrap(PointerType::get(unwrap(ElementType)));
+  // FIXME: Needst to handle address spaces
+  return wrap(PointerType::getUnqual(unwrap(ElementType)));
 }
 
 LLVMTypeRef LLVMVectorType(LLVMTypeRef ElementType,unsigned ElementCount){

diff --git a/lib/VMCore/Function.cpp b/lib/VMCore/Function.cpp
index 856385bb0082fb96a0d176929baaa6429e7dfea6..f985899b207a08dc9728b250bab5bff9c70bd48a 100644 (file)
--- a/lib/VMCore/Function.cpp
+++ b/lib/VMCore/Function.cpp
@@ -271,7 +271,8 @@ ParamAttrsList::~ParamAttrsList() {
 
 Function::Function(const FunctionType *Ty, LinkageTypes Linkage,
                    const std::string &name, Module *ParentModule)
-  : GlobalValue(PointerType::get(Ty), Value::FunctionVal, 0, 0, Linkage, name),
+  : GlobalValue(PointerType::getUnqual(Ty), 
+                Value::FunctionVal, 0, 0, Linkage, name),
     ParamAttrs(0) {
   SymTab = new ValueSymbolTable();
 

diff --git a/lib/VMCore/InlineAsm.cpp b/lib/VMCore/InlineAsm.cpp
index ca4ecad058c058ffea5fb897230cb5801800040c..e3634e2be539d8e296c09e6e933dff171db936e1 100644 (file)
--- a/lib/VMCore/InlineAsm.cpp
+++ b/lib/VMCore/InlineAsm.cpp
@@ -34,7 +34,9 @@ InlineAsm *InlineAsm::get(const FunctionType *Ty, const std::string &AsmString,
 
 InlineAsm::InlineAsm(const FunctionType *Ty, const std::string &asmString,
                      const std::string &constraints, bool hasSideEffects)
-  : Value(PointerType::get(Ty), Value::InlineAsmVal), AsmString(asmString), 
+  : Value(PointerType::getUnqual(Ty), 
+          Value::InlineAsmVal), 
+    AsmString(asmString), 
     Constraints(constraints), HasSideEffects(hasSideEffects) {
 
   // Do various checks on the constraint string and type.

diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp
index 511a0e851a10e9747a6ff5d5c66f52b78497ce36..6c8a072c19749fa3836e177a1d513a8a12cbcf6c 100644 (file)
--- a/lib/VMCore/Instructions.cpp
+++ b/lib/VMCore/Instructions.cpp
@@ -72,8 +72,6 @@ bool CallSite::isNoUnwind() const {
     return cast<InvokeInst>(I)->isNoUnwind();
 }
 
-
-
 //===----------------------------------------------------------------------===//
 //                            TerminatorInst Class
 //===----------------------------------------------------------------------===//
@@ -672,7 +670,7 @@ static Value *getAISize(Value *Amt) {
 AllocationInst::AllocationInst(const Type *Ty, Value *ArraySize, unsigned iTy,
                                unsigned Align, const std::string &Name,
                                Instruction *InsertBefore)
-  : UnaryInstruction(PointerType::get(Ty), iTy, getAISize(ArraySize),
+  : UnaryInstruction(PointerType::getUnqual(Ty), iTy, getAISize(ArraySize),
                      InsertBefore), Alignment(Align) {
   assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
   assert(Ty != Type::VoidTy && "Cannot allocate void!");
@@ -682,7 +680,7 @@ AllocationInst::AllocationInst(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::get(Ty), iTy, getAISize(ArraySize),
+  : UnaryInstruction(PointerType::getUnqual(Ty), iTy, getAISize(ArraySize),
                      InsertAtEnd), Alignment(Align) {
   assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
   assert(Ty != Type::VoidTy && "Cannot allocate void!");
@@ -925,6 +923,10 @@ void StoreInst::setAlignment(unsigned Align) {
 //                       GetElementPtrInst Implementation
 //===----------------------------------------------------------------------===//
 
+static unsigned retrieveAddrSpace(const Value *Val) {
+  return cast<PointerType>(Val->getType())->getAddressSpace();
+}
+
 void GetElementPtrInst::init(Value *Ptr, Value* const *Idx, unsigned NumIdx) {
   NumOperands = 1+NumIdx;
   Use *OL = OperandList = new Use[NumOperands];
@@ -944,7 +946,7 @@ void GetElementPtrInst::init(Value *Ptr, Value *Idx) {
 GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
                                      const std::string &Name, Instruction *InBe)
   : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx)),
-                      cast<PointerType>(Ptr->getType())->getAddressSpace()),
+                                 retrieveAddrSpace(Ptr)),
                 GetElementPtr, 0, 0, InBe) {
   init(Ptr, Idx);
   setName(Name);
@@ -953,7 +955,7 @@ GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
 GetElementPtrInst::GetElementPtrInst(Value *Ptr, Value *Idx,
                                      const std::string &Name, BasicBlock *IAE)
   : Instruction(PointerType::get(checkType(getIndexedType(Ptr->getType(),Idx)),
-                      cast<PointerType>(Ptr->getType())->getAddressSpace()),
+                                 retrieveAddrSpace(Ptr)),
                 GetElementPtr, 0, 0, IAE) {
   init(Ptr, Idx);
   setName(Name);

diff --git a/lib/VMCore/Module.cpp b/lib/VMCore/Module.cpp
index e20dab30be99c4767c93463e13fe22a7b988301d..56b510927de5a3e8a34d44d1ded0d4a43bb84d15 100644 (file)
--- a/lib/VMCore/Module.cpp
+++ b/lib/VMCore/Module.cpp
@@ -164,8 +164,8 @@ Constant *Module::getOrInsertFunction(const std::string &Name,
 
   // If the function exists but has the wrong type, return a bitcast to the
   // right type.
-  if (F->getType() != PointerType::get(Ty))
-    return ConstantExpr::getBitCast(F, PointerType::get(Ty));
+  if (F->getType() != PointerType::getUnqual(Ty))
+    return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty));
   
   // Otherwise, we just found the existing function or a prototype.
   return F;  

diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp
index fb8db1785daff8e4fedc64791e14924645a8f291..08f031f40ed60b8dc8137952d7821a006302744f 100644 (file)
--- a/lib/VMCore/Verifier.cpp
+++ b/lib/VMCore/Verifier.cpp
@@ -1161,12 +1161,12 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
     break;
   case Intrinsic::gcwrite:
     Assert1(CI.getOperand(3)->getType()
-            == PointerType::get(CI.getOperand(1)->getType()),
+            == PointerType::getUnqual(CI.getOperand(1)->getType()),
             "Call to llvm.gcwrite must be with type 'void (%ty*, %ty2*, %ty**)'.",
             &CI);
     break;
   case Intrinsic::gcread:
-    Assert1(CI.getOperand(2)->getType() == PointerType::get(CI.getType()),
+    Assert1(CI.getOperand(2)->getType() == PointerType::getUnqual(CI.getType()),
             "Call to llvm.gcread must be with type '%ty* (%ty2*, %ty**).'",
             &CI);
     break;

diff --git a/tools/bugpoint/Miscompilation.cpp b/tools/bugpoint/Miscompilation.cpp
index 6bf42d4c519476d3432bf12b09250e64f6ab91e4..b8731b055cb3d25c9240f7c0951f9f0e7418bb00 100644 (file)
--- a/tools/bugpoint/Miscompilation.cpp
+++ b/tools/bugpoint/Miscompilation.cpp
@@ -679,8 +679,8 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
   // Prototype: void *getPointerToNamedFunction(const char* Name)
   Constant *resolverFunc =
     Safe->getOrInsertFunction("getPointerToNamedFunction",
-                              PointerType::get(Type::Int8Ty),
-                              PointerType::get(Type::Int8Ty), (Type *)0);
+                              PointerType::getUnqual(Type::Int8Ty),
+                              PointerType::getUnqual(Type::Int8Ty), (Type *)0);
 
   // Use the function we just added to get addresses of functions we need.
   for (Module::iterator F = Safe->begin(), E = Safe->end(); F != E; ++F) {
@@ -739,7 +739,7 @@ static void CleanupAndPrepareModules(BugDriver &BD, Module *&Test,
                                             "resolver", LookupBB);
           // cast the result from the resolver to correctly-typed function
           CastInst *CastedResolver = new BitCastInst(Resolver, 
-            PointerType::get(F->getFunctionType()), "resolverCast", LookupBB);
+            PointerType::getUnqual(F->getFunctionType()), "resolverCast", LookupBB);
 
           // Save the value in our cache.
           new StoreInst(CastedResolver, Cache, LookupBB);

diff --git a/tools/llvm-upgrade/UpgradeParser.y b/tools/llvm-upgrade/UpgradeParser.y
index 7a6e3efc7b0b36056c379606343774c95c02a5b8..bcabaa3cabaaf09ba495757d620a6faf30962a87 100644 (file)
--- a/tools/llvm-upgrade/UpgradeParser.y
+++ b/tools/llvm-upgrade/UpgradeParser.y
@@ -829,7 +829,7 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
   if (isa<FunctionType>(Ty))
     error("Cannot declare global vars of function type");
 
-  const PointerType *PTy = PointerType::get(Ty);
+  const PointerType *PTy = PointerType::getUnqual(Ty);
 
   std::string Name;
   if (NameStr) {
@@ -883,7 +883,8 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage,
       }
 
       // Put the renaming in the global rename map
-      RenameMapKey Key = makeRenameMapKey(Name, PointerType::get(Ty), ID.S);
+      RenameMapKey Key = 
+        makeRenameMapKey(Name, PointerType::getUnqual(Ty), ID.S);
       CurModule.RenameMap[Key] = NewName;
 
       // Rename it
@@ -1404,7 +1405,7 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
       break;
 
     case 'v' : {
-      const Type* PtrTy = PointerType::get(Type::Int8Ty);
+      const Type* PtrTy = PointerType::getUnqual(Type::Int8Ty);
       std::vector<const Type*> Params;
       if (Name == "llvm.va_start" || Name == "llvm.va_end") {
         if (Args.size() != 1)
@@ -1412,7 +1413,7 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
         Params.push_back(PtrTy);
         const FunctionType *FTy = 
           FunctionType::get(Type::VoidTy, Params, false);
-        const PointerType *PFTy = PointerType::get(FTy);
+        const PointerType *PFTy = PointerType::getUnqual(FTy);
         Value* Func = getVal(PFTy, ID);
         Args[0] = new BitCastInst(Args[0], PtrTy, makeNameUnique("va"), CurBB);
         return new CallInst(Func, Args.begin(), Args.end());
@@ -1423,7 +1424,7 @@ upgradeIntrinsicCall(const Type* RetTy, const ValID &ID,
         Params.push_back(PtrTy);
         const FunctionType *FTy = 
           FunctionType::get(Type::VoidTy, Params, false);
-        const PointerType *PFTy = PointerType::get(FTy);
+        const PointerType *PFTy = PointerType::getUnqual(FTy);
         Value* Func = getVal(PFTy, ID);
         std::string InstName0(makeNameUnique("va0"));
         std::string InstName1(makeNameUnique("va1"));
@@ -1592,7 +1593,7 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in,
 
       const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
       const Type* ArgTy = F->getFunctionType()->getReturnType();
-      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      const Type* ArgTyPtr = PointerType::getUnqual(ArgTy);
       Function* NF = cast<Function>(Result->getOrInsertFunction(
         "llvm.va_start", RetTy, ArgTyPtr, (Type *)0));
 
@@ -1619,7 +1620,7 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in,
       //vaend bar
       const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
       const Type* ArgTy = F->getFunctionType()->getParamType(0);
-      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      const Type* ArgTyPtr = PointerType::getUnqual(ArgTy);
       Function* NF = cast<Function>(Result->getOrInsertFunction(
         "llvm.va_end", RetTy, ArgTyPtr, (Type *)0));
 
@@ -1648,7 +1649,7 @@ Module* UpgradeAssembly(const std::string &infile, std::istream& in,
       
       const Type* RetTy = Type::getPrimitiveType(Type::VoidTyID);
       const Type* ArgTy = F->getFunctionType()->getReturnType();
-      const Type* ArgTyPtr = PointerType::get(ArgTy);
+      const Type* ArgTyPtr = PointerType::getUnqual(ArgTy);
       Function* NF = cast<Function>(Result->getOrInsertFunction(
         "llvm.va_copy", RetTy, ArgTyPtr, ArgTyPtr, (Type *)0));
 
@@ -2126,8 +2127,9 @@ UpRTypes
     if ($1.PAT->get() == Type::LabelTy)
       error("Cannot form a pointer to a basic block");
     $$.S.makeComposite($1.S);
-    $$.PAT = new PATypeHolder(HandleUpRefs(PointerType::get($1.PAT->get()),
-                                           $$.S));
+    $$.PAT = new  
+      PATypeHolder(HandleUpRefs(PointerType::getUnqual($1.PAT->get()),
+                                $$.S));
     delete $1.PAT;
   }
   ;
@@ -2834,10 +2836,10 @@ FunctionHeaderH
     // i8*. We check here for those names and override the parameter list
     // types to ensure the prototype is correct.
     if (FunctionName == "llvm.va_start" || FunctionName == "llvm.va_end") {
-      ParamTyList.push_back(PointerType::get(Type::Int8Ty));
+      ParamTyList.push_back(PointerType::getUnqual(Type::Int8Ty));
     } else if (FunctionName == "llvm.va_copy") {
-      ParamTyList.push_back(PointerType::get(Type::Int8Ty));
-      ParamTyList.push_back(PointerType::get(Type::Int8Ty));
+      ParamTyList.push_back(PointerType::getUnqual(Type::Int8Ty));
+      ParamTyList.push_back(PointerType::getUnqual(Type::Int8Ty));
     } else if ($5) {   // If there are arguments...
       for (std::vector<std::pair<PATypeInfo,char*> >::iterator 
            I = $5->begin(), E = $5->end(); I != E; ++I) {
@@ -2852,7 +2854,7 @@ FunctionHeaderH
       ParamTyList.pop_back();
 
     const FunctionType *FT = FunctionType::get(RetTy, ParamTyList, isVarArg);
-    const PointerType *PFT = PointerType::get(FT);
+    const PointerType *PFT = PointerType::getUnqual(FT);
     delete $2.PAT;
 
     ValID ID;
@@ -3102,7 +3104,8 @@ ConstValueRef
   }
   ;
 
-// SymbolicValueRef - Reference to one of two ways of symbolically refering to // another value.
+// SymbolicValueRef - Reference to one of two ways of symbolically refering to 
+// another value.
 //
 SymbolicValueRef 
   : INTVAL {  $$ = ValID::create($1); $$.S.makeSignless(); }
@@ -3251,7 +3254,7 @@ BBTerminatorInst
       bool isVarArg = ParamTypes.size() && ParamTypes.back() == Type::VoidTy;
       if (isVarArg) ParamTypes.pop_back();
       Ty = FunctionType::get($3.PAT->get(), ParamTypes, isVarArg);
-      PFTy = PointerType::get(Ty);
+      PFTy = PointerType::getUnqual(Ty);
       $$.S.copy($3.S);
     } else {
       FTySign = $3.S;
@@ -3656,7 +3659,7 @@ InstVal
         error("Functions cannot return aggregate types");
 
       FTy = FunctionType::get(RetTy, ParamTypes, isVarArg);
-      PFTy = PointerType::get(FTy);
+      PFTy = PointerType::getUnqual(FTy);
       $$.S.copy($3.S);
     } else {
       FTySign = $3.S;
@@ -3796,7 +3799,7 @@ MemoryInst
     Value *StoreVal = $3.V;
     Value* tmpVal = getVal(PTy, $6);
     if (ElTy != $3.V->getType()) {
-      PTy = PointerType::get(StoreVal->getType());
+      PTy = PointerType::getUnqual(StoreVal->getType());
       if (Constant *C = dyn_cast<Constant>(tmpVal))
         tmpVal = ConstantExpr::getBitCast(C, PTy);
       else

diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp
index 18bdc1b6668dd43b98ef9342f7fc7bd2d8572cae..b3aaf25a382d4ba3aa6f67987fe295cb3400e422 100644 (file)
--- a/tools/llvm2cpp/CppWriter.cpp
+++ b/tools/llvm2cpp/CppWriter.cpp
@@ -577,7 +577,8 @@ CppWriter::printTypeInternal(const Type* Ty) {
       bool isForward = printTypeInternal(ET);
       std::string elemName(getCppName(ET));
       Out << "PointerType* " << typeName << " = PointerType::get("
-          << elemName << (isForward ? "_fwd" : "") << ");";
+          << elemName << (isForward ? "_fwd" : "")
+          << ", " << utostr(PT->getAddressSpace()) << ");";
       nl(Out);
       break;
     }

diff --git a/utils/TableGen/IntrinsicEmitter.cpp b/utils/TableGen/IntrinsicEmitter.cpp
index 47569f3d412ba5b69e511be092c9f34a14d9567d..e19d4d8ad3ee4e82f1d27830360f4f9e814f50a0 100644 (file)
--- a/utils/TableGen/IntrinsicEmitter.cpp
+++ b/utils/TableGen/IntrinsicEmitter.cpp
@@ -158,7 +158,7 @@ static void EmitTypeGenerate(std::ostream &OS, Record *ArgType,
     EmitTypeForValueType(OS, MVT::getVectorElementType(VT));
     OS << ", " << MVT::getVectorNumElements(VT) << ")";
   } else if (VT == MVT::iPTR) {
-    OS << "PointerType::get(";
+    OS << "PointerType::getUnqual(";
     EmitTypeGenerate(OS, ArgType->getValueAsDef("ElTy"), ArgNo);
     OS << ")";
   } else if (VT == MVT::isVoid) {