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

Rename ConvertType to ConvertConstant to avoid a name conflict on llvm-gcc.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@78596 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Daniel Dunbar 2009-08-10 20:56:46 +00:00
parent d6662add68
commit e74f3c0ce6
2 changed files with 11 additions and 11 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Constants.h
View File

@ -38,7 +38,7 @@ class VectorType;
template<class ConstantClass, class TypeClass, class ValType> template<class ConstantClass, class TypeClass, class ValType>
struct ConstantCreator; struct ConstantCreator;
template<class ConstantClass, class TypeClass> template<class ConstantClass, class TypeClass>
struct ConvertType; struct ConvertConstant;
//===----------------------------------------------------------------------===// //===----------------------------------------------------------------------===//
/// This is the shared class of boolean and integer constants. This class /// This is the shared class of boolean and integer constants. This class
@ -552,7 +552,7 @@ public:
class ConstantExpr : public Constant { class ConstantExpr : public Constant {
friend struct ConstantCreator<ConstantExpr,Type, friend struct ConstantCreator<ConstantExpr,Type,
std::pair<unsigned, std::vector<Constant*> > >; std::pair<unsigned, std::vector<Constant*> > >;
friend struct ConvertType<ConstantExpr, Type>; friend struct ConvertConstant<ConstantExpr, Type>;
protected: protected:
ConstantExpr(const Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps) ConstantExpr(const Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)

18
lib/VMCore/ConstantsContext.h
View File

@ -340,7 +340,7 @@ struct ConstantCreator {
}; };
template<class ConstantClass, class TypeClass> template<class ConstantClass, class TypeClass>
struct ConvertType { struct ConvertConstant {
static void convert(ConstantClass *OldC, const TypeClass *NewTy) { static void convert(ConstantClass *OldC, const TypeClass *NewTy) {
llvm_unreachable("This type cannot be converted!"); llvm_unreachable("This type cannot be converted!");
} }
@ -391,7 +391,7 @@ struct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> {
}; };
template<> template<>
struct ConvertType<ConstantExpr, Type> { struct ConvertConstant<ConstantExpr, Type> {
static void convert(ConstantExpr *OldC, const Type *NewTy) { static void convert(ConstantExpr *OldC, const Type *NewTy) {
Constant *New; Constant *New;
switch (OldC->getOpcode()) { switch (OldC->getOpcode()) {
@ -451,7 +451,7 @@ struct ConstantCreator<MDNode, Type, std::vector<Value*> > {
}; };
template<> template<>
struct ConvertType<ConstantVector, VectorType> { struct ConvertConstant<ConstantVector, VectorType> {
static void convert(ConstantVector *OldC, const VectorType *NewTy) { static void convert(ConstantVector *OldC, const VectorType *NewTy) {
// Make everyone now use a constant of the new type... // Make everyone now use a constant of the new type...
std::vector<Constant*> C; std::vector<Constant*> C;
@ -465,7 +465,7 @@ struct ConvertType<ConstantVector, VectorType> {
}; };
template<> template<>
struct ConvertType<ConstantAggregateZero, Type> { struct ConvertConstant<ConstantAggregateZero, Type> {
static void convert(ConstantAggregateZero *OldC, const Type *NewTy) { static void convert(ConstantAggregateZero *OldC, const Type *NewTy) {
// Make everyone now use a constant of the new type... // Make everyone now use a constant of the new type...
Constant *New = ConstantAggregateZero::get(NewTy); Constant *New = ConstantAggregateZero::get(NewTy);
@ -476,7 +476,7 @@ struct ConvertType<ConstantAggregateZero, Type> {
}; };
template<> template<>
struct ConvertType<ConstantArray, ArrayType> { struct ConvertConstant<ConstantArray, ArrayType> {
static void convert(ConstantArray *OldC, const ArrayType *NewTy) { static void convert(ConstantArray *OldC, const ArrayType *NewTy) {
// Make everyone now use a constant of the new type... // Make everyone now use a constant of the new type...
std::vector<Constant*> C; std::vector<Constant*> C;
@ -490,7 +490,7 @@ struct ConvertType<ConstantArray, ArrayType> {
}; };
template<> template<>
struct ConvertType<ConstantStruct, StructType> { struct ConvertConstant<ConstantStruct, StructType> {
static void convert(ConstantStruct *OldC, const StructType *NewTy) { static void convert(ConstantStruct *OldC, const StructType *NewTy) {
// Make everyone now use a constant of the new type... // Make everyone now use a constant of the new type...
std::vector<Constant*> C; std::vector<Constant*> C;
@ -513,7 +513,7 @@ struct ConstantCreator<ConstantPointerNull, PointerType, ValType> {
}; };
template<> template<>
struct ConvertType<ConstantPointerNull, PointerType> { struct ConvertConstant<ConstantPointerNull, PointerType> {
static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) { static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) {
// Make everyone now use a constant of the new type... // Make everyone now use a constant of the new type...
Constant *New = ConstantPointerNull::get(NewTy); Constant *New = ConstantPointerNull::get(NewTy);
@ -532,7 +532,7 @@ struct ConstantCreator<UndefValue, Type, ValType> {
}; };
template<> template<>
struct ConvertType<UndefValue, Type> { struct ConvertConstant<UndefValue, Type> {
static void convert(UndefValue *OldC, const Type *NewTy) { static void convert(UndefValue *OldC, const Type *NewTy) {
// Make everyone now use a constant of the new type. // Make everyone now use a constant of the new type.
Constant *New = UndefValue::get(NewTy); Constant *New = UndefValue::get(NewTy);
@ -757,7 +757,7 @@ public:
// leaving will remove() itself, causing the AbstractTypeMapEntry to be // leaving will remove() itself, causing the AbstractTypeMapEntry to be
// eliminated eventually. // eliminated eventually.
do { do {
ConvertType<ConstantClass, TypeClass>::convert( ConvertConstant<ConstantClass, TypeClass>::convert(
static_cast<ConstantClass *>(I->second->second), static_cast<ConstantClass *>(I->second->second),
cast<TypeClass>(NewTy)); cast<TypeClass>(NewTy));