RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2025-01-18 16:03:17 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

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.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@45082 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Christopher Lamb 2007-12-17 01:12:55 +00:00
parent 303dae993a
commit 43ad6b3e0d
32 changed files with 172 additions and 137 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
examples/BrainF/BrainF.cpp
View File

@ -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;

2
examples/BrainF/BrainFDriver.cpp
View File

@ -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();

11
include/llvm/DerivedTypes.h
View File

@ -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; }

6
lib/AsmParser/llvmAsmParser.y
View File

@ -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...

2
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -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");

17
lib/CodeGen/IntrinsicLowering.cpp
View File

@ -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:

4
lib/CodeGen/MachineModuleInfo.cpp
View File

@ -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;

5
lib/ExecutionEngine/ExecutionEngine.cpp
View File

@ -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) {

7
lib/Target/MSIL/MSILWriter.cpp
View File

@ -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) {

4
lib/Transforms/IPO/GlobalOpt.cpp
View File

@ -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);
}

10
lib/Transforms/IPO/LowerSetJmp.cpp
View File

@ -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 =

11
lib/Transforms/IPO/RaiseAllocations.cpp
View File

@ -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);

52
lib/Transforms/IPO/SimplifyLibCalls.cpp
View File

@ -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;

5
lib/Transforms/Instrumentation/ProfilingUtils.cpp
View File

@ -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,

32
lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -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);

14
lib/Transforms/Scalar/LowerGC.cpp
View File

@ -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.

4
lib/Transforms/Utils/CodeExtractor.cpp
View File

@ -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);
}

2
lib/Transforms/Utils/InlineFunction.cpp
View File

@ -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);

7
lib/Transforms/Utils/LowerAllocations.cpp
View File

@ -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();

11
lib/Transforms/Utils/LowerInvoke.cpp
View File

@ -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);
}

11
lib/VMCore/ConstantFold.cpp
View File

@ -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()));
}
}

2
lib/VMCore/Constants.cpp
View File

@ -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);
}

3
lib/VMCore/Core.cpp
View File

@ -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){

3
lib/VMCore/Function.cpp
View File

@ -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();

4
lib/VMCore/InlineAsm.cpp
View File

@ -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.

14
lib/VMCore/Instructions.cpp
View File

@ -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);

4
lib/VMCore/Module.cpp
View File

@ -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;

4
lib/VMCore/Verifier.cpp
View File

@ -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;

6
tools/bugpoint/Miscompilation.cpp
View File

@ -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);

39
tools/llvm-upgrade/UpgradeParser.y
View File

@ -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

3
tools/llvm2cpp/CppWriter.cpp
View File

@ -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;
}

2
utils/TableGen/IntrinsicEmitter.cpp
View File

@ -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) {