From 43ad6b3e0d6ada51e9b23aab3e061187f1f5710c Mon Sep 17 00:00:00 2001 From: Christopher Lamb Date: Mon, 17 Dec 2007 01:12:55 +0000 Subject: [PATCH] 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 --- examples/BrainF/BrainF.cpp | 8 +-- examples/BrainF/BrainFDriver.cpp | 2 +- include/llvm/DerivedTypes.h | 11 +++- lib/AsmParser/llvmAsmParser.y | 6 +-- lib/Bitcode/Reader/BitcodeReader.cpp | 2 +- lib/CodeGen/IntrinsicLowering.cpp | 17 +++--- lib/CodeGen/MachineModuleInfo.cpp | 4 +- lib/ExecutionEngine/ExecutionEngine.cpp | 5 +- lib/Target/MSIL/MSILWriter.cpp | 7 +-- lib/Transforms/IPO/GlobalOpt.cpp | 4 +- lib/Transforms/IPO/LowerSetJmp.cpp | 10 ++-- lib/Transforms/IPO/RaiseAllocations.cpp | 11 ++-- lib/Transforms/IPO/SimplifyLibCalls.cpp | 52 +++++++++---------- .../Instrumentation/ProfilingUtils.cpp | 5 +- .../Scalar/InstructionCombining.cpp | 32 +++++++----- lib/Transforms/Scalar/LowerGC.cpp | 14 ++--- lib/Transforms/Utils/CodeExtractor.cpp | 4 +- lib/Transforms/Utils/InlineFunction.cpp | 2 +- lib/Transforms/Utils/LowerAllocations.cpp | 7 +-- lib/Transforms/Utils/LowerInvoke.cpp | 11 ++-- lib/VMCore/ConstantFold.cpp | 11 ++-- lib/VMCore/Constants.cpp | 2 +- lib/VMCore/Core.cpp | 3 +- lib/VMCore/Function.cpp | 3 +- lib/VMCore/InlineAsm.cpp | 4 +- lib/VMCore/Instructions.cpp | 14 ++--- lib/VMCore/Module.cpp | 4 +- lib/VMCore/Verifier.cpp | 4 +- tools/bugpoint/Miscompilation.cpp | 6 +-- tools/llvm-upgrade/UpgradeParser.y | 39 +++++++------- tools/llvm2cpp/CppWriter.cpp | 3 +- utils/TableGen/IntrinsicEmitter.cpp | 2 +- 32 files changed, 172 insertions(+), 137 deletions(-) diff --git a/examples/BrainF/BrainF.cpp b/examples/BrainF/BrainF.cpp index e7e11aca0b1..b75b51943c2 100644 --- 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(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(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 7d29fe6f72f..3f3b6c33928 100644 --- 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(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 d62cb3bcc95..c294f402e68 100644 --- 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 c1f52a2eb03..855034cd92d 100644 --- 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 72756ef6cd6..4e761e402b8 100644 --- 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 0d1da867ed0..ef14f0b322f 100644 --- 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 9943fa99676..14253f41117 100644 --- 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()); // 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 83c0094a493..6c2d9c38419 100644 --- 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 87107d8908d..cc4739a8b0c 100644 --- 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(&*I); if (AI && !isa(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 f574ed46063..a858fb22fa9 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(), 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 90ece1799da..389ddebc6a0 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 Args = diff --git a/lib/Transforms/IPO/RaiseAllocations.cpp b/lib/Transforms/IPO/RaiseAllocations.cpp index e6d8723f457..ca4be9e528b 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(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(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(), 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(1, PointerType::get(Type::Int8Ty)), false); + std::vector(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(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 0904c4c6c19..1547b6c308e 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(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(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(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(FT->getParamType(0)) && isa(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(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(FT->getParamType(1)) && isa(FT->getParamType(3)) && @@ -1927,7 +1927,7 @@ static bool GetConstantStringInfo(Value *V, std::string &Str) { static Value *CastToCStr(Value *V, Instruction *IP) { assert(isa(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 91b8ec2c5c9..dacd92aef76 100644 --- 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 aa9e932fc52..7989ebf1979 100644 --- 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(CI->getOperand(0)->getType())) { + unsigned AS = + cast(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(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(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(I)) { + unsigned AS = + cast(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 9935a84cda8..e7a9997bc1f 100644 --- 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 c42d5e177d3..98b3f2b9401 100644 --- 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 e9f6b28e98b..e88eb942826 100644 --- 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 b089cd6d8b4..c5c8bd50da8 100644 --- 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(), true); @@ -158,8 +158,9 @@ bool LowerAllocations::runOnBasicBlock(BasicBlock &BB) { Changed = true; ++NumLowered; } else if (FreeInst *FI = dyn_cast(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 24b167ac877..db49b780fd9 100644 --- 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 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 a99ae9ded8a..20e04cae4fb 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -1383,12 +1383,13 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, return const_cast(C); if (isa(C)) { - const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), + const PointerType *Ptr = cast(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(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 964d8880e87..83070c00e14 100644 --- 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 b910cf15011..9a7c7909e81 100644 --- 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 856385bb008..f985899b207 100644 --- 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 ca4ecad058c..e3634e2be53 100644 --- 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 511a0e851a1..6c8a072c197 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -72,8 +72,6 @@ bool CallSite::isNoUnwind() const { return cast(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(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(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(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 e20dab30be9..56b510927de 100644 --- 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 fb8db1785da..08f031f40ed 100644 --- 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 6bf42d4c519..b8731b055cb 100644 --- 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 7a6e3efc7b0..bcabaa3caba 100644 --- a/tools/llvm-upgrade/UpgradeParser.y +++ b/tools/llvm-upgrade/UpgradeParser.y @@ -829,7 +829,7 @@ ParseGlobalVariable(char *NameStr,GlobalValue::LinkageTypes Linkage, if (isa(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 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(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(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(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 >::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(tmpVal)) tmpVal = ConstantExpr::getBitCast(C, PTy); else diff --git a/tools/llvm2cpp/CppWriter.cpp b/tools/llvm2cpp/CppWriter.cpp index 18bdc1b6668..b3aaf25a382 100644 --- 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 47569f3d412..e19d4d8ad3e 100644 --- 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) { -- 2.34.1