6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 20:32:21 +00:00
Code Issues Projects Releases Wiki Activity

Second attempt at de-constifying LLVM Types in FunctionType::get(),

Browse Source 
StructType::get() and TargetData::getIntPtrType().

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134982 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Jay Foad 2011-07-12 14:06:48 +00:00
parent d475c10508
commit 5fdd6c8793
36 changed files with 129 additions and 154 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
include/llvm/DerivedTypes.h
View File

@ -102,8 +102,6 @@ public:
/// FunctionType::get - This static method is the primary way of constructing /// FunctionType::get - This static method is the primary way of constructing
/// a FunctionType. /// a FunctionType.
/// ///
static FunctionType *get(const Type *Result,
ArrayRef<const Type*> Params, bool isVarArg);
static FunctionType *get(const Type *Result, static FunctionType *get(const Type *Result,
ArrayRef<Type*> Params, bool isVarArg); ArrayRef<Type*> Params, bool isVarArg);
@ -206,11 +204,6 @@ public:
/// StructType::get - This static method is the primary way to create a /// StructType::get - This static method is the primary way to create a
/// StructType. /// StructType.
///
/// FIXME: Remove the 'const Type*' version of this when types are pervasively
/// de-constified.
static StructType *get(LLVMContext &Context, ArrayRef<const Type*> Elements,
bool isPacked = false);
static StructType *get(LLVMContext &Context, ArrayRef<Type*> Elements, static StructType *get(LLVMContext &Context, ArrayRef<Type*> Elements,
bool isPacked = false); bool isPacked = false);
@ -222,7 +215,7 @@ public:
/// structure types by specifying the elements as arguments. Note that this /// structure types by specifying the elements as arguments. Note that this
/// method always returns a non-packed struct, and requires at least one /// method always returns a non-packed struct, and requires at least one
/// element type. /// element type.
static StructType *get(const Type *elt1, ...) END_WITH_NULL; static StructType *get(Type *elt1, ...) END_WITH_NULL;
bool isPacked() const { return (getSubclassData() & SCDB_Packed) != 0; } bool isPacked() const { return (getSubclassData() & SCDB_Packed) != 0; }

6
include/llvm/Intrinsics.h
View File

@ -44,12 +44,12 @@ namespace Intrinsic {
/// Intrinsic::getName(ID) - Return the LLVM name for an intrinsic, such as /// Intrinsic::getName(ID) - Return the LLVM name for an intrinsic, such as
/// "llvm.ppc.altivec.lvx". /// "llvm.ppc.altivec.lvx".
std::string getName(ID id, const Type **Tys = 0, unsigned numTys = 0); std::string getName(ID id, Type **Tys = 0, unsigned numTys = 0);
/// Intrinsic::getType(ID) - Return the function type for an intrinsic. /// Intrinsic::getType(ID) - Return the function type for an intrinsic.
/// ///
const FunctionType *getType(LLVMContext &Context, ID id, const FunctionType *getType(LLVMContext &Context, ID id,
const Type **Tys = 0, unsigned numTys = 0); Type **Tys = 0, unsigned numTys = 0);
/// Intrinsic::isOverloaded(ID) - Returns true if the intrinsic can be /// Intrinsic::isOverloaded(ID) - Returns true if the intrinsic can be
/// overloaded. /// overloaded.
@ -67,7 +67,7 @@ namespace Intrinsic {
/// overloaded intrinsic, Tys should point to an array of numTys pointers to /// overloaded intrinsic, Tys should point to an array of numTys pointers to
/// Type, and must provide exactly one type for each overloaded type in the /// Type, and must provide exactly one type for each overloaded type in the
/// intrinsic. /// intrinsic.
Function *getDeclaration(Module *M, ID id, const Type **Tys = 0, Function *getDeclaration(Module *M, ID id, Type **Tys = 0,
unsigned numTys = 0); unsigned numTys = 0);
/// Map a GCC builtin name to an intrinsic ID. /// Map a GCC builtin name to an intrinsic ID.

74
include/llvm/Support/TypeBuilder.h
View File

@ -51,7 +51,7 @@ namespace llvm {
/// namespace llvm { /// namespace llvm {
/// template<bool xcompile> class TypeBuilder<MyType, xcompile> { /// template<bool xcompile> class TypeBuilder<MyType, xcompile> {
/// public: /// public:
/// static const StructType *get(LLVMContext &Context) { /// static StructType *get(LLVMContext &Context) {
/// // If you cache this result, be sure to cache it separately /// // If you cache this result, be sure to cache it separately
/// // for each LLVMContext. /// // for each LLVMContext.
/// return StructType::get( /// return StructType::get(
@ -104,7 +104,7 @@ template<typename T, bool cross> class TypeBuilder<const volatile T, cross>
// Pointers // Pointers
template<typename T, bool cross> class TypeBuilder<T*, cross> { template<typename T, bool cross> class TypeBuilder<T*, cross> {
public: public:
static const PointerType *get(LLVMContext &Context) { static PointerType *get(LLVMContext &Context) {
return PointerType::getUnqual(TypeBuilder<T,cross>::get(Context)); return PointerType::getUnqual(TypeBuilder<T,cross>::get(Context));
} }
}; };
@ -115,14 +115,14 @@ template<typename T, bool cross> class TypeBuilder<T&, cross> {};
// Arrays // Arrays
template<typename T, size_t N, bool cross> class TypeBuilder<T[N], cross> { template<typename T, size_t N, bool cross> class TypeBuilder<T[N], cross> {
public: public:
static const ArrayType *get(LLVMContext &Context) { static ArrayType *get(LLVMContext &Context) {
return ArrayType::get(TypeBuilder<T, cross>::get(Context), N); return ArrayType::get(TypeBuilder<T, cross>::get(Context), N);
} }
}; };
/// LLVM uses an array of length 0 to represent an unknown-length array. /// LLVM uses an array of length 0 to represent an unknown-length array.
template<typename T, bool cross> class TypeBuilder<T[], cross> { template<typename T, bool cross> class TypeBuilder<T[], cross> {
public: public:
static const ArrayType *get(LLVMContext &Context) { static ArrayType *get(LLVMContext &Context) {
return ArrayType::get(TypeBuilder<T, cross>::get(Context), 0); return ArrayType::get(TypeBuilder<T, cross>::get(Context), 0);
} }
}; };
@ -152,7 +152,7 @@ public:
#define DEFINE_INTEGRAL_TYPEBUILDER(T) \ #define DEFINE_INTEGRAL_TYPEBUILDER(T) \
template<> class TypeBuilder<T, false> { \ template<> class TypeBuilder<T, false> { \
public: \ public: \
static const IntegerType *get(LLVMContext &Context) { \ static IntegerType *get(LLVMContext &Context) { \
return IntegerType::get(Context, sizeof(T) * CHAR_BIT); \ return IntegerType::get(Context, sizeof(T) * CHAR_BIT); \
} \ } \
}; \ }; \
@ -181,14 +181,14 @@ DEFINE_INTEGRAL_TYPEBUILDER(unsigned long long);
template<uint32_t num_bits, bool cross> template<uint32_t num_bits, bool cross>
class TypeBuilder<types::i<num_bits>, cross> { class TypeBuilder<types::i<num_bits>, cross> {
public: public:
static const IntegerType *get(LLVMContext &C) { static IntegerType *get(LLVMContext &C) {
return IntegerType::get(C, num_bits); return IntegerType::get(C, num_bits);
} }
}; };
template<> class TypeBuilder<float, false> { template<> class TypeBuilder<float, false> {
public: public:
static const Type *get(LLVMContext& C) { static Type *get(LLVMContext& C) {
return Type::getFloatTy(C); return Type::getFloatTy(C);
} }
}; };
@ -196,7 +196,7 @@ template<> class TypeBuilder<float, true> {};
template<> class TypeBuilder<double, false> { template<> class TypeBuilder<double, false> {
public: public:
static const Type *get(LLVMContext& C) { static Type *get(LLVMContext& C) {
return Type::getDoubleTy(C); return Type::getDoubleTy(C);
} }
}; };
@ -204,32 +204,32 @@ template<> class TypeBuilder<double, true> {};
template<bool cross> class TypeBuilder<types::ieee_float, cross> { template<bool cross> class TypeBuilder<types::ieee_float, cross> {
public: public:
static const Type *get(LLVMContext& C) { return Type::getFloatTy(C); } static Type *get(LLVMContext& C) { return Type::getFloatTy(C); }
}; };
template<bool cross> class TypeBuilder<types::ieee_double, cross> { template<bool cross> class TypeBuilder<types::ieee_double, cross> {
public: public:
static const Type *get(LLVMContext& C) { return Type::getDoubleTy(C); } static Type *get(LLVMContext& C) { return Type::getDoubleTy(C); }
}; };
template<bool cross> class TypeBuilder<types::x86_fp80, cross> { template<bool cross> class TypeBuilder<types::x86_fp80, cross> {
public: public:
static const Type *get(LLVMContext& C) { return Type::getX86_FP80Ty(C); } static Type *get(LLVMContext& C) { return Type::getX86_FP80Ty(C); }
}; };
template<bool cross> class TypeBuilder<types::fp128, cross> { template<bool cross> class TypeBuilder<types::fp128, cross> {
public: public:
static const Type *get(LLVMContext& C) { return Type::getFP128Ty(C); } static Type *get(LLVMContext& C) { return Type::getFP128Ty(C); }
}; };
template<bool cross> class TypeBuilder<types::ppc_fp128, cross> { template<bool cross> class TypeBuilder<types::ppc_fp128, cross> {
public: public:
static const Type *get(LLVMContext& C) { return Type::getPPC_FP128Ty(C); } static Type *get(LLVMContext& C) { return Type::getPPC_FP128Ty(C); }
}; };
template<bool cross> class TypeBuilder<types::x86_mmx, cross> { template<bool cross> class TypeBuilder<types::x86_mmx, cross> {
public: public:
static const Type *get(LLVMContext& C) { return Type::getX86_MMXTy(C); } static Type *get(LLVMContext& C) { return Type::getX86_MMXTy(C); }
}; };
template<bool cross> class TypeBuilder<void, cross> { template<bool cross> class TypeBuilder<void, cross> {
public: public:
static const Type *get(LLVMContext &C) { static Type *get(LLVMContext &C) {
return Type::getVoidTy(C); return Type::getVoidTy(C);
} }
}; };
@ -247,14 +247,14 @@ template<> class TypeBuilder<const volatile void*, false>
template<typename R, bool cross> class TypeBuilder<R(), cross> { template<typename R, bool cross> class TypeBuilder<R(), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
return FunctionType::get(TypeBuilder<R, cross>::get(Context), false); return FunctionType::get(TypeBuilder<R, cross>::get(Context), false);
} }
}; };
template<typename R, typename A1, bool cross> class TypeBuilder<R(A1), cross> { template<typename R, typename A1, bool cross> class TypeBuilder<R(A1), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(1); params.reserve(1);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
return FunctionType::get(TypeBuilder<R, cross>::get(Context), return FunctionType::get(TypeBuilder<R, cross>::get(Context),
@ -264,8 +264,8 @@ public:
template<typename R, typename A1, typename A2, bool cross> template<typename R, typename A1, typename A2, bool cross>
class TypeBuilder<R(A1, A2), cross> { class TypeBuilder<R(A1, A2), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(2); params.reserve(2);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));
@ -276,8 +276,8 @@ public:
template<typename R, typename A1, typename A2, typename A3, bool cross> template<typename R, typename A1, typename A2, typename A3, bool cross>
class TypeBuilder<R(A1, A2, A3), cross> { class TypeBuilder<R(A1, A2, A3), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(3); params.reserve(3);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));
@ -291,8 +291,8 @@ template<typename R, typename A1, typename A2, typename A3, typename A4,
bool cross> bool cross>
class TypeBuilder<R(A1, A2, A3, A4), cross> { class TypeBuilder<R(A1, A2, A3, A4), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(4); params.reserve(4);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));
@ -307,8 +307,8 @@ template<typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, bool cross> typename A5, bool cross>
class TypeBuilder<R(A1, A2, A3, A4, A5), cross> { class TypeBuilder<R(A1, A2, A3, A4, A5), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(5); params.reserve(5);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));
@ -322,15 +322,15 @@ public:
template<typename R, bool cross> class TypeBuilder<R(...), cross> { template<typename R, bool cross> class TypeBuilder<R(...), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
return FunctionType::get(TypeBuilder<R, cross>::get(Context), true); return FunctionType::get(TypeBuilder<R, cross>::get(Context), true);
} }
}; };
template<typename R, typename A1, bool cross> template<typename R, typename A1, bool cross>
class TypeBuilder<R(A1, ...), cross> { class TypeBuilder<R(A1, ...), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(1); params.reserve(1);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
return FunctionType::get(TypeBuilder<R, cross>::get(Context), params, true); return FunctionType::get(TypeBuilder<R, cross>::get(Context), params, true);
@ -339,8 +339,8 @@ public:
template<typename R, typename A1, typename A2, bool cross> template<typename R, typename A1, typename A2, bool cross>
class TypeBuilder<R(A1, A2, ...), cross> { class TypeBuilder<R(A1, A2, ...), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(2); params.reserve(2);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));
@ -351,8 +351,8 @@ public:
template<typename R, typename A1, typename A2, typename A3, bool cross> template<typename R, typename A1, typename A2, typename A3, bool cross>
class TypeBuilder<R(A1, A2, A3, ...), cross> { class TypeBuilder<R(A1, A2, A3, ...), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(3); params.reserve(3);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));
@ -366,8 +366,8 @@ template<typename R, typename A1, typename A2, typename A3, typename A4,
bool cross> bool cross>
class TypeBuilder<R(A1, A2, A3, A4, ...), cross> { class TypeBuilder<R(A1, A2, A3, A4, ...), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(4); params.reserve(4);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));
@ -382,8 +382,8 @@ template<typename R, typename A1, typename A2, typename A3, typename A4,
typename A5, bool cross> typename A5, bool cross>
class TypeBuilder<R(A1, A2, A3, A4, A5, ...), cross> { class TypeBuilder<R(A1, A2, A3, A4, A5, ...), cross> {
public: public:
static const FunctionType *get(LLVMContext &Context) { static FunctionType *get(LLVMContext &Context) {
std::vector<const Type*> params; std::vector<Type*> params;
params.reserve(5); params.reserve(5);
params.push_back(TypeBuilder<A1, cross>::get(Context)); params.push_back(TypeBuilder<A1, cross>::get(Context));
params.push_back(TypeBuilder<A2, cross>::get(Context)); params.push_back(TypeBuilder<A2, cross>::get(Context));

8
lib/AsmParser/LLParser.cpp
View File

@ -1442,7 +1442,7 @@ bool LLParser::ParseFunctionType(Type *&Result) {
"argument attributes invalid in function type"); "argument attributes invalid in function type");
} }
SmallVector<const Type*, 16> ArgListTy; SmallVector<Type*, 16> ArgListTy;
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
ArgListTy.push_back(ArgList[i].Ty); ArgListTy.push_back(ArgList[i].Ty);
@ -2655,7 +2655,7 @@ bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
// Okay, if we got here, the function is syntactically valid. Convert types // Okay, if we got here, the function is syntactically valid. Convert types
// and do semantic checks. // and do semantic checks.
std::vector<const Type*> ParamTypeList; std::vector<Type*> ParamTypeList;
SmallVector<AttributeWithIndex, 8> Attrs; SmallVector<AttributeWithIndex, 8> Attrs;
if (RetAttrs != Attribute::None) if (RetAttrs != Attribute::None)
@ -3171,7 +3171,7 @@ bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
if (!(PFTy = dyn_cast<PointerType>(RetType)) || if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
// Pull out the types of all of the arguments... // Pull out the types of all of the arguments...
std::vector<const Type*> ParamTypes; std::vector<Type*> ParamTypes;
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
ParamTypes.push_back(ArgList[i].V->getType()); ParamTypes.push_back(ArgList[i].V->getType());
@ -3508,7 +3508,7 @@ bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
if (!(PFTy = dyn_cast<PointerType>(RetType)) || if (!(PFTy = dyn_cast<PointerType>(RetType)) ||
!(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) { !(Ty = dyn_cast<FunctionType>(PFTy->getElementType()))) {
// Pull out the types of all of the arguments... // Pull out the types of all of the arguments...
std::vector<const Type*> ParamTypes; std::vector<Type*> ParamTypes;
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
ParamTypes.push_back(ArgList[i].V->getType()); ParamTypes.push_back(ArgList[i].V->getType());

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

@ -582,7 +582,7 @@ bool BitcodeReader::ParseTypeTableBody() {
// FUNCTION: [vararg, attrid, retty, paramty x N] // FUNCTION: [vararg, attrid, retty, paramty x N]
if (Record.size() < 3) if (Record.size() < 3)
return Error("Invalid FUNCTION type record"); return Error("Invalid FUNCTION type record");
std::vector<const Type*> ArgTys; std::vector<Type*> ArgTys;
for (unsigned i = 3, e = Record.size(); i != e; ++i) { for (unsigned i = 3, e = Record.size(); i != e; ++i) {
if (Type *T = getTypeByID(Record[i])) if (Type *T = getTypeByID(Record[i]))
ArgTys.push_back(T); ArgTys.push_back(T);
@ -838,7 +838,7 @@ RestartScan:
// FUNCTION: [vararg, attrid, retty, paramty x N] // FUNCTION: [vararg, attrid, retty, paramty x N]
if (Record.size() < 3) if (Record.size() < 3)
return Error("Invalid FUNCTION type record"); return Error("Invalid FUNCTION type record");
std::vector<const Type*> ArgTys; std::vector<Type*> ArgTys;
for (unsigned i = 3, e = Record.size(); i != e; ++i) { for (unsigned i = 3, e = Record.size(); i != e; ++i) {
if (Type *Elt = getTypeByIDOrNull(Record[i])) if (Type *Elt = getTypeByIDOrNull(Record[i]))
ArgTys.push_back(Elt); ArgTys.push_back(Elt);

4
lib/CodeGen/DwarfEHPrepare.cpp
View File

@ -497,10 +497,8 @@ bool DwarfEHPrepare::LowerUnwindsAndResumes() {
// Find the rewind function if we didn't already. // Find the rewind function if we didn't already.
if (!RewindFunction) { if (!RewindFunction) {
LLVMContext &Ctx = ResumeInsts[0]->getContext(); LLVMContext &Ctx = ResumeInsts[0]->getContext();
std::vector<const Type*>
Params(1, Type::getInt8PtrTy(Ctx));
FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx), FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
Params, false); Type::getInt8PtrTy(Ctx), false);
const char *RewindName = TLI->getLibcallName(RTLIB::UNWIND_RESUME); const char *RewindName = TLI->getLibcallName(RTLIB::UNWIND_RESUME);
RewindFunction = F->getParent()->getOrInsertFunction(RewindName, FTy); RewindFunction = F->getParent()->getOrInsertFunction(RewindName, FTy);
} }

8
lib/CodeGen/IntrinsicLowering.cpp
View File

@ -29,7 +29,7 @@ static void EnsureFunctionExists(Module &M, const char *Name,
ArgIt ArgBegin, ArgIt ArgEnd, ArgIt ArgBegin, ArgIt ArgEnd,
const Type *RetTy) { const Type *RetTy) {
// Insert a correctly-typed definition now. // Insert a correctly-typed definition now.
std::vector<const Type *> ParamTys; std::vector<Type *> ParamTys;
for (ArgIt I = ArgBegin; I != ArgEnd; ++I) for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
ParamTys.push_back(I->getType()); ParamTys.push_back(I->getType());
M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false)); M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false));
@ -69,7 +69,7 @@ static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
// program already contains a function with this name. // program already contains a function with this name.
Module *M = CI->getParent()->getParent()->getParent(); Module *M = CI->getParent()->getParent()->getParent();
// Get or insert the definition now. // Get or insert the definition now.
std::vector<const Type *> ParamTys; std::vector<Type *> ParamTys;
for (ArgIt I = ArgBegin; I != ArgEnd; ++I) for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
ParamTys.push_back((*I)->getType()); ParamTys.push_back((*I)->getType());
Constant* FCache = M->getOrInsertFunction(NewFn, Constant* FCache = M->getOrInsertFunction(NewFn,
@ -553,12 +553,12 @@ bool IntrinsicLowering::LowerToByteSwap(CallInst *CI) {
!CI->getType()->isIntegerTy()) !CI->getType()->isIntegerTy())
return false; return false;
const IntegerType *Ty = dyn_cast<IntegerType>(CI->getType()); IntegerType *Ty = dyn_cast<IntegerType>(CI->getType());
if (!Ty) if (!Ty)
return false; return false;
// Okay, we can do this xform, do so now. // Okay, we can do this xform, do so now.
const Type *Tys[] = { Ty }; Type *Tys[] = { Ty };
Module *M = CI->getParent()->getParent()->getParent(); Module *M = CI->getParent()->getParent()->getParent();
Constant *Int = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1); Constant *Int = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1);

5
lib/CodeGen/SjLjEHPrepare.cpp
View File

@ -87,9 +87,8 @@ FunctionPass *llvm::createSjLjEHPass(const TargetLowering *TLI) {
bool SjLjEHPass::doInitialization(Module &M) { bool SjLjEHPass::doInitialization(Module &M) {
// Build the function context structure. // Build the function context structure.
// builtin_setjmp uses a five word jbuf // builtin_setjmp uses a five word jbuf
const Type *VoidPtrTy = Type *VoidPtrTy = Type::getInt8PtrTy(M.getContext());
Type::getInt8PtrTy(M.getContext()); Type *Int32Ty = Type::getInt32Ty(M.getContext());
const Type *Int32Ty = Type::getInt32Ty(M.getContext());
FunctionContextTy = FunctionContextTy =
StructType::get(VoidPtrTy, // __prev StructType::get(VoidPtrTy, // __prev
Int32Ty, // call_site Int32Ty, // call_site

4
lib/Target/ARM/ARMGlobalMerge.cpp
View File

@ -128,10 +128,10 @@ bool ARMGlobalMerge::doMerge(SmallVectorImpl<GlobalVariable*> &Globals,
for (size_t i = 0, e = Globals.size(); i != e; ) { for (size_t i = 0, e = Globals.size(); i != e; ) {
size_t j = 0; size_t j = 0;
uint64_t MergedSize = 0; uint64_t MergedSize = 0;
std::vector<const Type*> Tys; std::vector<Type*> Tys;
std::vector<Constant*> Inits; std::vector<Constant*> Inits;
for (j = i; j != e; ++j) { for (j = i; j != e; ++j) {
const Type *Ty = Globals[j]->getType()->getElementType(); Type *Ty = Globals[j]->getType()->getElementType();
MergedSize += TD->getTypeAllocSize(Ty); MergedSize += TD->getTypeAllocSize(Ty);
if (MergedSize > MaxOffset) { if (MergedSize > MaxOffset) {
break; break;

2
lib/Target/Blackfin/BlackfinIntrinsicInfo.cpp
View File

@ -83,7 +83,7 @@ bool BlackfinIntrinsicInfo::isOverloaded(unsigned IntrID) const {
static const FunctionType *getType(LLVMContext &Context, unsigned id) { static const FunctionType *getType(LLVMContext &Context, unsigned id) {
const Type *ResultTy = NULL; const Type *ResultTy = NULL;
std::vector<const Type*> ArgTys; std::vector<Type*> ArgTys;
bool IsVarArg = false; bool IsVarArg = false;
#define GET_INTRINSIC_GENERATOR #define GET_INTRINSIC_GENERATOR

2
lib/Target/MBlaze/MBlazeIntrinsicInfo.cpp
View File

@ -92,7 +92,7 @@ bool MBlazeIntrinsicInfo::isOverloaded(unsigned IntrID) const {
static const FunctionType *getType(LLVMContext &Context, unsigned id) { static const FunctionType *getType(LLVMContext &Context, unsigned id) {
const Type *ResultTy = NULL; const Type *ResultTy = NULL;
std::vector<const Type*> ArgTys; std::vector<Type*> ArgTys;
bool IsVarArg = false; bool IsVarArg = false;
#define GET_INTRINSIC_GENERATOR #define GET_INTRINSIC_GENERATOR

2
lib/Transforms/IPO/ArgumentPromotion.cpp
View File

@ -493,7 +493,7 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F,
// Start by computing a new prototype for the function, which is the same as // Start by computing a new prototype for the function, which is the same as
// the old function, but has modified arguments. // the old function, but has modified arguments.
const FunctionType *FTy = F->getFunctionType(); const FunctionType *FTy = F->getFunctionType();
std::vector<const Type*> Params; std::vector<Type*> Params;
typedef std::set<IndicesVector> ScalarizeTable; typedef std::set<IndicesVector> ScalarizeTable;

8
lib/Transforms/IPO/DeadArgumentElimination.cpp
View File

@ -208,7 +208,7 @@ bool DAE::DeleteDeadVarargs(Function &Fn) {
// the old function, but doesn't have isVarArg set. // the old function, but doesn't have isVarArg set.
const FunctionType *FTy = Fn.getFunctionType(); const FunctionType *FTy = Fn.getFunctionType();
std::vector<const Type*> Params(FTy->param_begin(), FTy->param_end()); std::vector<Type*> Params(FTy->param_begin(), FTy->param_end());
FunctionType *NFTy = FunctionType::get(FTy->getReturnType(), FunctionType *NFTy = FunctionType::get(FTy->getReturnType(),
Params, false); Params, false);
unsigned NumArgs = Params.size(); unsigned NumArgs = Params.size();
@ -647,7 +647,7 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
// Start by computing a new prototype for the function, which is the same as // Start by computing a new prototype for the function, which is the same as
// the old function, but has fewer arguments and a different return type. // the old function, but has fewer arguments and a different return type.
const FunctionType *FTy = F->getFunctionType(); const FunctionType *FTy = F->getFunctionType();
std::vector<const Type*> Params; std::vector<Type*> Params;
// Set up to build a new list of parameter attributes. // Set up to build a new list of parameter attributes.
SmallVector<AttributeWithIndex, 8> AttributesVec; SmallVector<AttributeWithIndex, 8> AttributesVec;
@ -659,13 +659,13 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) {
// Find out the new return value. // Find out the new return value.
const Type *RetTy = FTy->getReturnType(); Type *RetTy = FTy->getReturnType();
const Type *NRetTy = NULL; const Type *NRetTy = NULL;
unsigned RetCount = NumRetVals(F); unsigned RetCount = NumRetVals(F);
// -1 means unused, other numbers are the new index // -1 means unused, other numbers are the new index
SmallVector<int, 5> NewRetIdxs(RetCount, -1); SmallVector<int, 5> NewRetIdxs(RetCount, -1);
std::vector<const Type*> RetTypes; std::vector<Type*> RetTypes;
if (RetTy->isVoidTy()) { if (RetTy->isVoidTy()) {
NRetTy = RetTy; NRetTy = RetTy;
} else { } else {

4
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
View File

@ -1400,7 +1400,7 @@ static bool CollectBSwapParts(Value *V, int OverallLeftShift, uint32_t ByteMask,
/// MatchBSwap - Given an OR instruction, check to see if this is a bswap idiom. /// MatchBSwap - Given an OR instruction, check to see if this is a bswap idiom.
/// If so, insert the new bswap intrinsic and return it. /// If so, insert the new bswap intrinsic and return it.
Instruction *InstCombiner::MatchBSwap(BinaryOperator &I) { Instruction *InstCombiner::MatchBSwap(BinaryOperator &I) {
const IntegerType *ITy = dyn_cast<IntegerType>(I.getType()); IntegerType *ITy = dyn_cast<IntegerType>(I.getType());
if (!ITy || ITy->getBitWidth() % 16 || if (!ITy || ITy->getBitWidth() % 16 ||
// ByteMask only allows up to 32-byte values. // ByteMask only allows up to 32-byte values.
ITy->getBitWidth() > 32*8) ITy->getBitWidth() > 32*8)
@ -1424,7 +1424,7 @@ Instruction *InstCombiner::MatchBSwap(BinaryOperator &I) {
for (unsigned i = 1, e = ByteValues.size(); i != e; ++i) for (unsigned i = 1, e = ByteValues.size(); i != e; ++i)
if (ByteValues[i] != V) if (ByteValues[i] != V)
return 0; return 0;
const Type *Tys[] = { ITy }; Type *Tys[] = { ITy };
Module *M = I.getParent()->getParent()->getParent(); Module *M = I.getParent()->getParent()->getParent();
Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1); Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, Tys, 1);
return CallInst::Create(F, V); return CallInst::Create(F, V);

10
lib/Transforms/InstCombine/InstCombineCalls.cpp
View File

@ -217,9 +217,9 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
if (GVSrc->isConstant()) { if (GVSrc->isConstant()) {
Module *M = CI.getParent()->getParent()->getParent(); Module *M = CI.getParent()->getParent()->getParent();
Intrinsic::ID MemCpyID = Intrinsic::memcpy; Intrinsic::ID MemCpyID = Intrinsic::memcpy;
const Type *Tys[3] = { CI.getArgOperand(0)->getType(), Type *Tys[3] = { CI.getArgOperand(0)->getType(),
CI.getArgOperand(1)->getType(), CI.getArgOperand(1)->getType(),
CI.getArgOperand(2)->getType() }; CI.getArgOperand(2)->getType() };
CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys, 3)); CI.setCalledFunction(Intrinsic::getDeclaration(M, MemCpyID, Tys, 3));
Changed = true; Changed = true;
} }
@ -1187,7 +1187,7 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) {
const AttrListPtr &NestAttrs = NestF->getAttributes(); const AttrListPtr &NestAttrs = NestF->getAttributes();
if (!NestAttrs.isEmpty()) { if (!NestAttrs.isEmpty()) {
unsigned NestIdx = 1; unsigned NestIdx = 1;
const Type *NestTy = 0; Type *NestTy = 0;
Attributes NestAttr = Attribute::None; Attributes NestAttr = Attribute::None;
// Look for a parameter marked with the 'nest' attribute. // Look for a parameter marked with the 'nest' attribute.
@ -1249,7 +1249,7 @@ Instruction *InstCombiner::transformCallThroughTrampoline(CallSite CS) {
// Handle this by synthesizing a new function type, equal to FTy // Handle this by synthesizing a new function type, equal to FTy
// with the chain parameter inserted. // with the chain parameter inserted.
std::vector<const Type*> NewTypes; std::vector<Type*> NewTypes;
NewTypes.reserve(FTy->getNumParams()+1); NewTypes.reserve(FTy->getNumParams()+1);
// Insert the chain's type into the list of parameter types, which may // Insert the chain's type into the list of parameter types, which may

4
lib/Transforms/InstCombine/InstCombineCompares.cpp
View File

@ -1683,7 +1683,7 @@ static Instruction *ProcessUGT_ADDCST_ADD(ICmpInst &I, Value *A, Value *B,
// result and the overflow bit. // result and the overflow bit.
Module *M = I.getParent()->getParent()->getParent(); Module *M = I.getParent()->getParent()->getParent();
const Type *NewType = IntegerType::get(OrigAdd->getContext(), NewWidth); Type *NewType = IntegerType::get(OrigAdd->getContext(), NewWidth);
Value *F = Intrinsic::getDeclaration(M, Intrinsic::sadd_with_overflow, Value *F = Intrinsic::getDeclaration(M, Intrinsic::sadd_with_overflow,
&NewType, 1); &NewType, 1);
@ -1725,7 +1725,7 @@ static Instruction *ProcessUAddIdiom(Instruction &I, Value *OrigAddV,
Builder->SetInsertPoint(OrigAdd); Builder->SetInsertPoint(OrigAdd);
Module *M = I.getParent()->getParent()->getParent(); Module *M = I.getParent()->getParent()->getParent();
const Type *Ty = LHS->getType(); Type *Ty = LHS->getType();
Value *F = Intrinsic::getDeclaration(M, Intrinsic::uadd_with_overflow, &Ty,1); Value *F = Intrinsic::getDeclaration(M, Intrinsic::uadd_with_overflow, &Ty,1);
CallInst *Call = Builder->CreateCall2(F, LHS, RHS, "uadd"); CallInst *Call = Builder->CreateCall2(F, LHS, RHS, "uadd");
Value *Add = Builder->CreateExtractValue(Call, 0); Value *Add = Builder->CreateExtractValue(Call, 0);

9
lib/Transforms/Instrumentation/GCOVProfiling.cpp
View File

@ -572,14 +572,13 @@ GlobalVariable *GCOVProfiler::buildEdgeLookupTable(
} }
Constant *GCOVProfiler::getStartFileFunc() { Constant *GCOVProfiler::getStartFileFunc() {
const Type *Args[] = { Type::getInt8PtrTy(*Ctx) };
const FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), const FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx),
Args, false); Type::getInt8PtrTy(*Ctx), false);
return M->getOrInsertFunction("llvm_gcda_start_file", FTy); return M->getOrInsertFunction("llvm_gcda_start_file", FTy);
} }
Constant *GCOVProfiler::getIncrementIndirectCounterFunc() { Constant *GCOVProfiler::getIncrementIndirectCounterFunc() {
const Type *Args[] = { Type *Args[] = {
Type::getInt32PtrTy(*Ctx), // uint32_t *predecessor Type::getInt32PtrTy(*Ctx), // uint32_t *predecessor
Type::getInt64PtrTy(*Ctx)->getPointerTo(), // uint64_t **state_table_row Type::getInt64PtrTy(*Ctx)->getPointerTo(), // uint64_t **state_table_row
}; };
@ -589,7 +588,7 @@ Constant *GCOVProfiler::getIncrementIndirectCounterFunc() {
} }
Constant *GCOVProfiler::getEmitFunctionFunc() { Constant *GCOVProfiler::getEmitFunctionFunc() {
const Type *Args[2] = { Type *Args[2] = {
Type::getInt32Ty(*Ctx), // uint32_t ident Type::getInt32Ty(*Ctx), // uint32_t ident
Type::getInt8PtrTy(*Ctx), // const char *function_name Type::getInt8PtrTy(*Ctx), // const char *function_name
}; };
@ -599,7 +598,7 @@ Constant *GCOVProfiler::getEmitFunctionFunc() {
} }
Constant *GCOVProfiler::getEmitArcsFunc() { Constant *GCOVProfiler::getEmitArcsFunc() {
const Type *Args[] = { Type *Args[] = {
Type::getInt32Ty(*Ctx), // uint32_t num_counters Type::getInt32Ty(*Ctx), // uint32_t num_counters
Type::getInt64PtrTy(*Ctx), // uint64_t *counters Type::getInt64PtrTy(*Ctx), // uint64_t *counters
}; };

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

@ -134,7 +134,7 @@ void llvm::IncrementCounterInBlock(BasicBlock *BB, unsigned CounterNum,
void llvm::InsertProfilingShutdownCall(Function *Callee, Module *Mod) { void llvm::InsertProfilingShutdownCall(Function *Callee, Module *Mod) {
// llvm.global_dtors is an array of type { i32, void ()* }. Prepare those // llvm.global_dtors is an array of type { i32, void ()* }. Prepare those
// types. // types.
const Type *GlobalDtorElems[2] = { Type *GlobalDtorElems[2] = {
Type::getInt32Ty(Mod->getContext()), Type::getInt32Ty(Mod->getContext()),
FunctionType::get(Type::getVoidTy(Mod->getContext()), false)->getPointerTo() FunctionType::get(Type::getVoidTy(Mod->getContext()), false)->getPointerTo()
}; };

6
lib/Transforms/Scalar/MemCpyOptimizer.cpp
View File

@ -840,9 +840,9 @@ bool MemCpyOpt::processMemMove(MemMoveInst *M) {
// If not, then we know we can transform this. // If not, then we know we can transform this.
Module *Mod = M->getParent()->getParent()->getParent(); Module *Mod = M->getParent()->getParent()->getParent();
const Type *ArgTys[3] = { M->getRawDest()->getType(), Type *ArgTys[3] = { M->getRawDest()->getType(),
M->getRawSource()->getType(), M->getRawSource()->getType(),
M->getLength()->getType() }; M->getLength()->getType() };
M->setCalledFunction(Intrinsic::getDeclaration(Mod, Intrinsic::memcpy, M->setCalledFunction(Intrinsic::getDeclaration(Mod, Intrinsic::memcpy,
ArgTys, 3)); ArgTys, 3));

28
lib/Transforms/Scalar/ObjCARC.cpp
View File

@ -1498,8 +1498,8 @@ void ObjCARCOpt::getAnalysisUsage(AnalysisUsage &AU) const {
Constant *ObjCARCOpt::getRetainRVCallee(Module *M) { Constant *ObjCARCOpt::getRetainRVCallee(Module *M) {
if (!RetainRVCallee) { if (!RetainRVCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
const Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(I8X); Params.push_back(I8X);
const FunctionType *FTy = const FunctionType *FTy =
FunctionType::get(I8X, Params, /*isVarArg=*/false); FunctionType::get(I8X, Params, /*isVarArg=*/false);
@ -1515,8 +1515,8 @@ Constant *ObjCARCOpt::getRetainRVCallee(Module *M) {
Constant *ObjCARCOpt::getAutoreleaseRVCallee(Module *M) { Constant *ObjCARCOpt::getAutoreleaseRVCallee(Module *M) {
if (!AutoreleaseRVCallee) { if (!AutoreleaseRVCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
const Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(I8X); Params.push_back(I8X);
const FunctionType *FTy = const FunctionType *FTy =
FunctionType::get(I8X, Params, /*isVarArg=*/false); FunctionType::get(I8X, Params, /*isVarArg=*/false);
@ -1532,7 +1532,7 @@ Constant *ObjCARCOpt::getAutoreleaseRVCallee(Module *M) {
Constant *ObjCARCOpt::getReleaseCallee(Module *M) { Constant *ObjCARCOpt::getReleaseCallee(Module *M) {
if (!ReleaseCallee) { if (!ReleaseCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(PointerType::getUnqual(Type::getInt8Ty(C))); Params.push_back(PointerType::getUnqual(Type::getInt8Ty(C)));
AttrListPtr Attributes; AttrListPtr Attributes;
Attributes.addAttr(~0u, Attribute::NoUnwind); Attributes.addAttr(~0u, Attribute::NoUnwind);
@ -1548,7 +1548,7 @@ Constant *ObjCARCOpt::getReleaseCallee(Module *M) {
Constant *ObjCARCOpt::getRetainCallee(Module *M) { Constant *ObjCARCOpt::getRetainCallee(Module *M) {
if (!RetainCallee) { if (!RetainCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(PointerType::getUnqual(Type::getInt8Ty(C))); Params.push_back(PointerType::getUnqual(Type::getInt8Ty(C)));
AttrListPtr Attributes; AttrListPtr Attributes;
Attributes.addAttr(~0u, Attribute::NoUnwind); Attributes.addAttr(~0u, Attribute::NoUnwind);
@ -1564,7 +1564,7 @@ Constant *ObjCARCOpt::getRetainCallee(Module *M) {
Constant *ObjCARCOpt::getAutoreleaseCallee(Module *M) { Constant *ObjCARCOpt::getAutoreleaseCallee(Module *M) {
if (!AutoreleaseCallee) { if (!AutoreleaseCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(PointerType::getUnqual(Type::getInt8Ty(C))); Params.push_back(PointerType::getUnqual(Type::getInt8Ty(C)));
AttrListPtr Attributes; AttrListPtr Attributes;
Attributes.addAttr(~0u, Attribute::NoUnwind); Attributes.addAttr(~0u, Attribute::NoUnwind);
@ -3269,9 +3269,9 @@ void ObjCARCContract::getAnalysisUsage(AnalysisUsage &AU) const {
Constant *ObjCARCContract::getStoreStrongCallee(Module *M) { Constant *ObjCARCContract::getStoreStrongCallee(Module *M) {
if (!StoreStrongCallee) { if (!StoreStrongCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
const Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
const Type *I8XX = PointerType::getUnqual(I8X); Type *I8XX = PointerType::getUnqual(I8X);
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(I8XX); Params.push_back(I8XX);
Params.push_back(I8X); Params.push_back(I8X);
@ -3291,8 +3291,8 @@ Constant *ObjCARCContract::getStoreStrongCallee(Module *M) {
Constant *ObjCARCContract::getRetainAutoreleaseCallee(Module *M) { Constant *ObjCARCContract::getRetainAutoreleaseCallee(Module *M) {
if (!RetainAutoreleaseCallee) { if (!RetainAutoreleaseCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
const Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(I8X); Params.push_back(I8X);
const FunctionType *FTy = const FunctionType *FTy =
FunctionType::get(I8X, Params, /*isVarArg=*/false); FunctionType::get(I8X, Params, /*isVarArg=*/false);
@ -3307,8 +3307,8 @@ Constant *ObjCARCContract::getRetainAutoreleaseCallee(Module *M) {
Constant *ObjCARCContract::getRetainAutoreleaseRVCallee(Module *M) { Constant *ObjCARCContract::getRetainAutoreleaseRVCallee(Module *M) {
if (!RetainAutoreleaseRVCallee) { if (!RetainAutoreleaseRVCallee) {
LLVMContext &C = M->getContext(); LLVMContext &C = M->getContext();
const Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C)); Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
std::vector<const Type *> Params; std::vector<Type *> Params;
Params.push_back(I8X); Params.push_back(I8X);
const FunctionType *FTy = const FunctionType *FTy =
FunctionType::get(I8X, Params, /*isVarArg=*/false); FunctionType::get(I8X, Params, /*isVarArg=*/false);

2
lib/Transforms/Scalar/SimplifyLibCalls.cpp
View File

@ -992,7 +992,7 @@ struct FFSOpt : public LibCallOptimization {
} }
// ffs(x) -> x != 0 ? (i32)llvm.cttz(x)+1 : 0 // ffs(x) -> x != 0 ? (i32)llvm.cttz(x)+1 : 0
const Type *ArgType = Op->getType(); Type *ArgType = Op->getType();
Value *F = Intrinsic::getDeclaration(Callee->getParent(), Value *F = Intrinsic::getDeclaration(Callee->getParent(),
Intrinsic::cttz, &ArgType, 1); Intrinsic::cttz, &ArgType, 1);
Value *V = B.CreateCall(F, Op, "cttz"); Value *V = B.CreateCall(F, Op, "cttz");

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

@ -140,7 +140,7 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
Function *llvm::CloneFunction(const Function *F, ValueToValueMapTy &VMap, Function *llvm::CloneFunction(const Function *F, ValueToValueMapTy &VMap,
bool ModuleLevelChanges, bool ModuleLevelChanges,
ClonedCodeInfo *CodeInfo) { ClonedCodeInfo *CodeInfo) {
std::vector<const Type*> ArgTypes; std::vector<Type*> ArgTypes;
// The user might be deleting arguments to the function by specifying them in // The user might be deleting arguments to the function by specifying them in
// the VMap. If so, we need to not add the arguments to the arg ty vector // the VMap. If so, we need to not add the arguments to the arg ty vector

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

@ -258,7 +258,7 @@ Function *CodeExtractor::constructFunction(const Values &inputs,
default: RetTy = Type::getInt16Ty(header->getContext()); break; default: RetTy = Type::getInt16Ty(header->getContext()); break;
} }
std::vector<const Type*> paramTy; std::vector<Type*> paramTy;
// Add the types of the input values to the function's argument list // Add the types of the input values to the function's argument list
for (Values::const_iterator i = inputs.begin(), for (Values::const_iterator i = inputs.begin(),
@ -279,7 +279,7 @@ Function *CodeExtractor::constructFunction(const Values &inputs,
} }
DEBUG(dbgs() << "Function type: " << *RetTy << " f("); DEBUG(dbgs() << "Function type: " << *RetTy << " f(");
for (std::vector<const Type*>::iterator i = paramTy.begin(), for (std::vector<Type*>::iterator i = paramTy.begin(),
e = paramTy.end(); i != e; ++i) e = paramTy.end(); i != e; ++i)
DEBUG(dbgs() << **i << ", "); DEBUG(dbgs() << **i << ", ");
DEBUG(dbgs() << ")\n"); DEBUG(dbgs() << ")\n");
@ -403,7 +403,7 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
AllocaInst *Struct = 0; AllocaInst *Struct = 0;
if (AggregateArgs && (inputs.size() + outputs.size() > 0)) { if (AggregateArgs && (inputs.size() + outputs.size() > 0)) {
std::vector<const Type*> ArgTypes; std::vector<Type*> ArgTypes;
for (Values::iterator v = StructValues.begin(), for (Values::iterator v = StructValues.begin(),
ve = StructValues.end(); v != ve; ++v) ve = StructValues.end(); v != ve; ++v)
ArgTypes.push_back((*v)->getType()); ArgTypes.push_back((*v)->getType());

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

@ -663,7 +663,7 @@ static Value *HandleByValArgument(Value *Arg, Instruction *TheCall,
LLVMContext &Context = Arg->getContext(); LLVMContext &Context = Arg->getContext();
const Type *VoidPtrTy = Type::getInt8PtrTy(Context); Type *VoidPtrTy = Type::getInt8PtrTy(Context);
// Create the alloca. If we have TargetData, use nice alignment. // Create the alloca. If we have TargetData, use nice alignment.
unsigned Align = 1; unsigned Align = 1;
@ -680,7 +680,7 @@ static Value *HandleByValArgument(Value *Arg, Instruction *TheCall,
Value *NewAlloca = new AllocaInst(AggTy, 0, Align, Arg->getName(), Value *NewAlloca = new AllocaInst(AggTy, 0, Align, Arg->getName(),
&*Caller->begin()->begin()); &*Caller->begin()->begin());
// Emit a memcpy. // Emit a memcpy.
const Type *Tys[3] = {VoidPtrTy, VoidPtrTy, Type::getInt64Ty(Context)}; Type *Tys[3] = {VoidPtrTy, VoidPtrTy, Type::getInt64Ty(Context)};
Function *MemCpyFn = Intrinsic::getDeclaration(Caller->getParent(), Function *MemCpyFn = Intrinsic::getDeclaration(Caller->getParent(),
Intrinsic::memcpy, Intrinsic::memcpy,
Tys, 3); Tys, 3);

2
lib/VMCore/Constants.cpp
View File

@ -619,7 +619,7 @@ Constant *ConstantArray::get(LLVMContext &Context, StringRef Str,
StructType *ConstantStruct::getTypeForElements(LLVMContext &Context, StructType *ConstantStruct::getTypeForElements(LLVMContext &Context,
ArrayRef<Constant*> V, ArrayRef<Constant*> V,
bool Packed) { bool Packed) {
SmallVector<const Type*, 16> EltTypes; SmallVector<Type*, 16> EltTypes;
for (unsigned i = 0, e = V.size(); i != e; ++i) for (unsigned i = 0, e = V.size(); i != e; ++i)
EltTypes.push_back(V[i]->getType()); EltTypes.push_back(V[i]->getType());

4
lib/VMCore/Core.cpp
View File

@ -260,7 +260,7 @@ LLVMTypeRef LLVMX86MMXType(void) {
LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType, LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
LLVMTypeRef *ParamTypes, unsigned ParamCount, LLVMTypeRef *ParamTypes, unsigned ParamCount,
LLVMBool IsVarArg) { LLVMBool IsVarArg) {
std::vector<const Type*> Tys; std::vector<Type*> Tys;
for (LLVMTypeRef *I = ParamTypes, *E = ParamTypes + ParamCount; I != E; ++I) for (LLVMTypeRef *I = ParamTypes, *E = ParamTypes + ParamCount; I != E; ++I)
Tys.push_back(unwrap(*I)); Tys.push_back(unwrap(*I));
@ -290,7 +290,7 @@ void LLVMGetParamTypes(LLVMTypeRef FunctionTy, LLVMTypeRef *Dest) {
LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes, LLVMTypeRef LLVMStructTypeInContext(LLVMContextRef C, LLVMTypeRef *ElementTypes,
unsigned ElementCount, LLVMBool Packed) { unsigned ElementCount, LLVMBool Packed) {
std::vector<const Type*> Tys; std::vector<Type*> Tys;
for (LLVMTypeRef *I = ElementTypes, for (LLVMTypeRef *I = ElementTypes,
*E = ElementTypes + ElementCount; I != E; ++I) *E = ElementTypes + ElementCount; I != E; ++I)
Tys.push_back(unwrap(*I)); Tys.push_back(unwrap(*I));

8
lib/VMCore/Function.cpp
View File

@ -333,7 +333,7 @@ unsigned Function::getIntrinsicID() const {
return 0; return 0;
} }
std::string Intrinsic::getName(ID id, const Type **Tys, unsigned numTys) { std::string Intrinsic::getName(ID id, Type **Tys, unsigned numTys) {
assert(id < num_intrinsics && "Invalid intrinsic ID!"); assert(id < num_intrinsics && "Invalid intrinsic ID!");
static const char * const Table[] = { static const char * const Table[] = {
"not_intrinsic", "not_intrinsic",
@ -356,10 +356,10 @@ std::string Intrinsic::getName(ID id, const Type **Tys, unsigned numTys) {
} }
const FunctionType *Intrinsic::getType(LLVMContext &Context, const FunctionType *Intrinsic::getType(LLVMContext &Context,
ID id, const Type **Tys, ID id, Type **Tys,
unsigned numTys) { unsigned numTys) {
const Type *ResultTy = NULL; const Type *ResultTy = NULL;
std::vector<const Type*> ArgTys; std::vector<Type*> ArgTys;
bool IsVarArg = false; bool IsVarArg = false;
#define GET_INTRINSIC_GENERATOR #define GET_INTRINSIC_GENERATOR
@ -384,7 +384,7 @@ bool Intrinsic::isOverloaded(ID id) {
#include "llvm/Intrinsics.gen" #include "llvm/Intrinsics.gen"
#undef GET_INTRINSIC_ATTRIBUTES #undef GET_INTRINSIC_ATTRIBUTES
Function *Intrinsic::getDeclaration(Module *M, ID id, const Type **Tys, Function *Intrinsic::getDeclaration(Module *M, ID id, Type **Tys,
unsigned numTys) { unsigned numTys) {
// There can never be multiple globals with the same name of different types, // There can never be multiple globals with the same name of different types,
// because intrinsics must be a specific type. // because intrinsics must be a specific type.

6
lib/VMCore/IRBuilder.cpp
View File

@ -65,7 +65,7 @@ CreateMemSet(Value *Ptr, Value *Val, Value *Size, unsigned Align,
bool isVolatile, MDNode *TBAATag) { bool isVolatile, MDNode *TBAATag) {
Ptr = getCastedInt8PtrValue(Ptr); Ptr = getCastedInt8PtrValue(Ptr);
Value *Ops[] = { Ptr, Val, Size, getInt32(Align), getInt1(isVolatile) }; Value *Ops[] = { Ptr, Val, Size, getInt32(Align), getInt1(isVolatile) };
const Type *Tys[] = { Ptr->getType(), Size->getType() }; Type *Tys[] = { Ptr->getType(), Size->getType() };
Module *M = BB->getParent()->getParent(); Module *M = BB->getParent()->getParent();
Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys, 2); Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys, 2);
@ -85,7 +85,7 @@ CreateMemCpy(Value *Dst, Value *Src, Value *Size, unsigned Align,
Src = getCastedInt8PtrValue(Src); Src = getCastedInt8PtrValue(Src);
Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) }; Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) };
const Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() }; Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
Module *M = BB->getParent()->getParent(); Module *M = BB->getParent()->getParent();
Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys, 3); Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys, 3);
@ -105,7 +105,7 @@ CreateMemMove(Value *Dst, Value *Src, Value *Size, unsigned Align,
Src = getCastedInt8PtrValue(Src); Src = getCastedInt8PtrValue(Src);
Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) }; Value *Ops[] = { Dst, Src, Size, getInt32(Align), getInt1(isVolatile) };
const Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() }; Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
Module *M = BB->getParent()->getParent(); Module *M = BB->getParent()->getParent();
Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys, 3); Value *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys, 3);

8
lib/VMCore/Module.cpp
View File

@ -216,8 +216,8 @@ Constant *Module::getOrInsertFunction(StringRef Name,
va_start(Args, RetTy); va_start(Args, RetTy);
// Build the list of argument types... // Build the list of argument types...
std::vector<const Type*> ArgTys; std::vector<Type*> ArgTys;
while (const Type *ArgTy = va_arg(Args, const Type*)) while (Type *ArgTy = va_arg(Args, Type*))
ArgTys.push_back(ArgTy); ArgTys.push_back(ArgTy);
va_end(Args); va_end(Args);
@ -234,8 +234,8 @@ Constant *Module::getOrInsertFunction(StringRef Name,
va_start(Args, RetTy); va_start(Args, RetTy);
// Build the list of argument types... // Build the list of argument types...
std::vector<const Type*> ArgTys; std::vector<Type*> ArgTys;
while (const Type *ArgTy = va_arg(Args, const Type*)) while (Type *ArgTy = va_arg(Args, Type*))
ArgTys.push_back(ArgTy); ArgTys.push_back(ArgTy);
va_end(Args); va_end(Args);

22
lib/VMCore/Type.cpp
View File

@ -325,13 +325,6 @@ FunctionType::FunctionType(const Type *Result, ArrayRef<Type*> Params,
NumContainedTys = Params.size() + 1; // + 1 for result type NumContainedTys = Params.size() + 1; // + 1 for result type
} }
// FIXME: Remove this version.
FunctionType *FunctionType::get(const Type *ReturnType,
ArrayRef<const Type*> Params, bool isVarArg) {
return get(ReturnType, ArrayRef<Type*>(const_cast<Type**>(Params.data()),
Params.size()), isVarArg);
}
// FunctionType::get - The factory function for the FunctionType class. // FunctionType::get - The factory function for the FunctionType class.
FunctionType *FunctionType::get(const Type *ReturnType, FunctionType *FunctionType::get(const Type *ReturnType,
ArrayRef<Type*> Params, bool isVarArg) { ArrayRef<Type*> Params, bool isVarArg) {
@ -357,7 +350,7 @@ FunctionType *FunctionType::get(const Type *ReturnType,
FunctionType *FunctionType::get(const Type *Result, bool isVarArg) { FunctionType *FunctionType::get(const Type *Result, bool isVarArg) {
return get(Result, ArrayRef<const Type *>(), isVarArg); return get(Result, ArrayRef<Type *>(), isVarArg);
} }
@ -465,22 +458,15 @@ void StructType::setName(StringRef Name) {
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
// StructType Helper functions. // StructType Helper functions.
// FIXME: Remove this version.
StructType *StructType::get(LLVMContext &Context, ArrayRef<const Type*>Elements,
bool isPacked) {
return get(Context, ArrayRef<Type*>(const_cast<Type**>(Elements.data()),
Elements.size()), isPacked);
}
StructType *StructType::get(LLVMContext &Context, bool isPacked) { StructType *StructType::get(LLVMContext &Context, bool isPacked) {
return get(Context, llvm::ArrayRef<const Type*>(), isPacked); return get(Context, llvm::ArrayRef<Type*>(), isPacked);
} }
StructType *StructType::get(const Type *type, ...) { StructType *StructType::get(Type *type, ...) {
assert(type != 0 && "Cannot create a struct type with no elements with this"); assert(type != 0 && "Cannot create a struct type with no elements with this");
LLVMContext &Ctx = type->getContext(); LLVMContext &Ctx = type->getContext();
va_list ap; va_list ap;
SmallVector<const llvm::Type*, 8> StructFields; SmallVector<llvm::Type*, 8> StructFields;
va_start(ap, type); va_start(ap, type);
while (type) { while (type) {
StructFields.push_back(type); StructFields.push_back(type);

2
tools/bugpoint/ExtractFunction.cpp
View File

@ -173,7 +173,7 @@ void llvm::DeleteFunctionBody(Function *F) {
static Constant *GetTorInit(std::vector<std::pair<Function*, int> > &TorList) { static Constant *GetTorInit(std::vector<std::pair<Function*, int> > &TorList) {
assert(!TorList.empty() && "Don't create empty tor list!"); assert(!TorList.empty() && "Don't create empty tor list!");
std::vector<Constant*> ArrayElts; std::vector<Constant*> ArrayElts;
const Type *Int32Ty = Type::getInt32Ty(TorList[0].first->getContext()); Type *Int32Ty = Type::getInt32Ty(TorList[0].first->getContext());
const StructType *STy = const StructType *STy =
StructType::get(Int32Ty, TorList[0].first->getType(), NULL); StructType::get(Int32Ty, TorList[0].first->getType(), NULL);

2
unittests/Analysis/ScalarEvolutionTest.cpp
View File

@ -23,7 +23,7 @@ TEST(ScalarEvolutionsTest, SCEVUnknownRAUW) {
Module M("world", Context); Module M("world", Context);
const FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), const FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
std::vector<const Type *>(), false); std::vector<Type *>(), false);
Function *F = cast<Function>(M.getOrInsertFunction("f", FTy)); Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
BasicBlock *BB = BasicBlock::Create(Context, "entry", F); BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
ReturnInst::Create(Context, 0, BB); ReturnInst::Create(Context, 0, BB);

2
unittests/ExecutionEngine/JIT/JITMemoryManagerTest.cpp
View File

@ -21,7 +21,7 @@ using namespace llvm;
namespace { namespace {
Function *makeFakeFunction() { Function *makeFakeFunction() {
std::vector<const Type*> params; std::vector<Type*> params;
const FunctionType *FTy = const FunctionType *FTy =
FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false); FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false);
return Function::Create(FTy, GlobalValue::ExternalLinkage); return Function::Create(FTy, GlobalValue::ExternalLinkage);

4
unittests/ExecutionEngine/JIT/JITTest.cpp
View File

@ -37,7 +37,7 @@ using namespace llvm;
namespace { namespace {
Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) { Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
std::vector<const Type*> params; std::vector<Type*> params;
const FunctionType *FTy = FunctionType::get(G->getType()->getElementType(), const FunctionType *FTy = FunctionType::get(G->getType()->getElementType(),
params, false); params, false);
Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M); Function *F = Function::Create(FTy, GlobalValue::ExternalLinkage, Name, M);
@ -322,7 +322,7 @@ TEST_F(JITTest, NonLazyCompilationStillNeedsStubs) {
const FunctionType *Func1Ty = const FunctionType *Func1Ty =
cast<FunctionType>(TypeBuilder<void(void), false>::get(Context)); cast<FunctionType>(TypeBuilder<void(void), false>::get(Context));
std::vector<const Type*> arg_types; std::vector<Type*> arg_types;
arg_types.push_back(Type::getInt1Ty(Context)); arg_types.push_back(Type::getInt1Ty(Context));
const FunctionType *FuncTy = FunctionType::get( const FunctionType *FuncTy = FunctionType::get(
Type::getVoidTy(Context), arg_types, false); Type::getVoidTy(Context), arg_types, false);

6
unittests/Support/TypeBuilderTest.cpp
View File

@ -120,7 +120,7 @@ TEST(TypeBuilderTest, Derived) {
} }
TEST(TypeBuilderTest, Functions) { TEST(TypeBuilderTest, Functions) {
std::vector<const Type*> params; std::vector<Type*> params;
EXPECT_EQ(FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false), EXPECT_EQ(FunctionType::get(Type::getVoidTy(getGlobalContext()), params, false),
(TypeBuilder<void(), true>::get(getGlobalContext()))); (TypeBuilder<void(), true>::get(getGlobalContext())));
EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true), EXPECT_EQ(FunctionType::get(Type::getInt8Ty(getGlobalContext()), params, true),
@ -187,7 +187,7 @@ public:
static const StructType *get(LLVMContext &Context) { static const StructType *get(LLVMContext &Context) {
// Using the static result variable ensures that the type is // Using the static result variable ensures that the type is
// only looked up once. // only looked up once.
std::vector<const Type*> st; std::vector<Type*> st;
st.push_back(TypeBuilder<int, cross>::get(Context)); st.push_back(TypeBuilder<int, cross>::get(Context));
st.push_back(TypeBuilder<int*, cross>::get(Context)); st.push_back(TypeBuilder<int*, cross>::get(Context));
st.push_back(TypeBuilder<void*[], cross>::get(Context)); st.push_back(TypeBuilder<void*[], cross>::get(Context));
@ -210,7 +210,7 @@ public:
static const StructType *get(LLVMContext &Context) { static const StructType *get(LLVMContext &Context) {
// Using the static result variable ensures that the type is // Using the static result variable ensures that the type is
// only looked up once. // only looked up once.
std::vector<const Type*> st; std::vector<Type*> st;
st.push_back(TypeBuilder<types::i<32>, cross>::get(Context)); st.push_back(TypeBuilder<types::i<32>, cross>::get(Context));
st.push_back(TypeBuilder<types::i<32>*, cross>::get(Context)); st.push_back(TypeBuilder<types::i<32>*, cross>::get(Context));
st.push_back(TypeBuilder<types::i<8>*[], cross>::get(Context)); st.push_back(TypeBuilder<types::i<8>*[], cross>::get(Context));

4
unittests/VMCore/PassManagerTest.cpp
View File

@ -405,13 +405,13 @@ namespace llvm {
mod->setTargetTriple("x86_64-unknown-linux-gnu"); mod->setTargetTriple("x86_64-unknown-linux-gnu");
// Type Definitions // Type Definitions
std::vector<const Type*>FuncTy_0_args; std::vector<Type*>FuncTy_0_args;
FunctionType* FuncTy_0 = FunctionType::get( FunctionType* FuncTy_0 = FunctionType::get(
/*Result=*/IntegerType::get(getGlobalContext(), 32), /*Result=*/IntegerType::get(getGlobalContext(), 32),
/*Params=*/FuncTy_0_args, /*Params=*/FuncTy_0_args,
/*isVarArg=*/false); /*isVarArg=*/false);
std::vector<const Type*>FuncTy_2_args; std::vector<Type*>FuncTy_2_args;
FuncTy_2_args.push_back(IntegerType::get(getGlobalContext(), 1)); FuncTy_2_args.push_back(IntegerType::get(getGlobalContext(), 1));
FunctionType* FuncTy_2 = FunctionType::get( FunctionType* FuncTy_2 = FunctionType::get(
/*Result=*/Type::getVoidTy(getGlobalContext()), /*Result=*/Type::getVoidTy(getGlobalContext()),