Rename ConstPoolVal -> Constant
Rename ConstPool* -> Constant*
Rename ConstPoolVals.h -> ConstantVals.h
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@1407 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/lib/AsmParser/ParserInternals.h b/lib/AsmParser/ParserInternals.h
index 76052fa..b05bb0d 100644
--- a/lib/AsmParser/ParserInternals.h
+++ b/lib/AsmParser/ParserInternals.h
@@ -13,7 +13,7 @@
#include "llvm/InstrTypes.h"
#include "llvm/BasicBlock.h"
-#include "llvm/ConstPoolVals.h"
+#include "llvm/ConstantVals.h"
#include "llvm/iOther.h"
#include "llvm/Method.h"
#include "llvm/DerivedTypes.h"
diff --git a/lib/AsmParser/llvmAsmParser.y b/lib/AsmParser/llvmAsmParser.y
index b5816f2..acc3cfd 100644
--- a/lib/AsmParser/llvmAsmParser.y
+++ b/lib/AsmParser/llvmAsmParser.y
@@ -58,7 +58,7 @@
// GlobalRefs - This maintains a mapping between <Type, ValID>'s and forward
// references to global values. Global values may be referenced before they
// are defined, and if so, the temporary object that they represent is held
- // here. This is used for forward references of ConstPoolPointerRefs.
+ // here. This is used for forward references of ConstantPointerRefs.
//
typedef map<pair<const PointerType *, ValID>, GlobalVariable*> GlobalRefsType;
GlobalRefsType GlobalRefs;
@@ -100,11 +100,11 @@
I->first.second.destroy(); // Free string memory if neccesary
// Loop over all of the uses of the GlobalValue. The only thing they are
- // allowed to be at this point is ConstPoolPointerRef's.
+ // allowed to be at this point is ConstantPointerRef's.
assert(OldGV->use_size() == 1 && "Only one reference should exist!");
while (!OldGV->use_empty()) {
- User *U = OldGV->use_back(); // Must be a ConstPoolPointerRef...
- ConstPoolPointerRef *CPPR = cast<ConstPoolPointerRef>(U);
+ User *U = OldGV->use_back(); // Must be a ConstantPointerRef...
+ ConstantPointerRef *CPPR = cast<ConstantPointerRef>(U);
assert(CPPR->getValue() == OldGV && "Something isn't happy");
// Change the const pool reference to point to the real global variable
@@ -296,24 +296,24 @@
// value will fit into the specified type...
case ValID::ConstSIntVal: // Is it a constant pool reference??
if (Ty == Type::BoolTy) { // Special handling for boolean data
- return ConstPoolBool::get(D.ConstPool64 != 0);
+ return ConstantBool::get(D.ConstPool64 != 0);
} else {
- if (!ConstPoolSInt::isValueValidForType(Ty, D.ConstPool64))
+ if (!ConstantSInt::isValueValidForType(Ty, D.ConstPool64))
ThrowException("Symbolic constant pool value '" +
itostr(D.ConstPool64) + "' is invalid for type '" +
Ty->getName() + "'!");
- return ConstPoolSInt::get(Ty, D.ConstPool64);
+ return ConstantSInt::get(Ty, D.ConstPool64);
}
case ValID::ConstUIntVal: // Is it an unsigned const pool reference?
- if (!ConstPoolUInt::isValueValidForType(Ty, D.UConstPool64)) {
- if (!ConstPoolSInt::isValueValidForType(Ty, D.ConstPool64)) {
+ if (!ConstantUInt::isValueValidForType(Ty, D.UConstPool64)) {
+ if (!ConstantSInt::isValueValidForType(Ty, D.ConstPool64)) {
ThrowException("Integral constant pool reference is invalid!");
} else { // This is really a signed reference. Transmogrify.
- return ConstPoolSInt::get(Ty, D.ConstPool64);
+ return ConstantSInt::get(Ty, D.ConstPool64);
}
} else {
- return ConstPoolUInt::get(Ty, D.UConstPool64);
+ return ConstantUInt::get(Ty, D.UConstPool64);
}
case ValID::ConstStringVal: // Is it a string const pool reference?
@@ -322,14 +322,14 @@
return 0;
case ValID::ConstFPVal: // Is it a floating point const pool reference?
- if (!ConstPoolFP::isValueValidForType(Ty, D.ConstPoolFP))
+ if (!ConstantFP::isValueValidForType(Ty, D.ConstPoolFP))
ThrowException("FP constant invalid for type!!");
- return ConstPoolFP::get(Ty, D.ConstPoolFP);
+ return ConstantFP::get(Ty, D.ConstPoolFP);
case ValID::ConstNullVal: // Is it a null value?
if (!Ty->isPointerType())
ThrowException("Cannot create a a non pointer null!");
- return ConstPoolPointerNull::get(cast<PointerType>(Ty));
+ return ConstantPointerNull::get(cast<PointerType>(Ty));
default:
assert(0 && "Unhandled case!");
@@ -635,7 +635,7 @@
BasicBlock *BasicBlockVal;
TerminatorInst *TermInstVal;
Instruction *InstVal;
- ConstPoolVal *ConstVal;
+ Constant *ConstVal;
const Type *PrimType;
PATypeHolder<Type> *TypeVal;
@@ -645,8 +645,8 @@
vector<Value*> *ValueList;
list<PATypeHolder<Type> > *TypeList;
list<pair<Value*, BasicBlock*> > *PHIList; // Represent the RHS of PHI node
- list<pair<ConstPoolVal*, BasicBlock*> > *JumpTable;
- vector<ConstPoolVal*> *ConstVector;
+ list<pair<Constant*, BasicBlock*> > *JumpTable;
+ vector<Constant*> *ConstVector;
int64_t SInt64Val;
uint64_t UInt64Val;
@@ -894,7 +894,7 @@
(*$3)[i]->getType()->getName() + "'.");
}
- $$ = ConstPoolArray::get(ATy, *$3);
+ $$ = ConstantArray::get(ATy, *$3);
delete $1; delete $3;
}
| Types '[' ']' {
@@ -907,7 +907,7 @@
if (NumElements != -1 && NumElements != 0)
ThrowException("Type mismatch: constant sized array initialized with 0"
" arguments, but has size of " + itostr(NumElements) +"!");
- $$ = ConstPoolArray::get(ATy, vector<ConstPoolVal*>());
+ $$ = ConstantArray::get(ATy, vector<Constant*>());
delete $1;
}
| Types 'c' STRINGCONSTANT {
@@ -923,19 +923,19 @@
ThrowException("Can't build string constant of size " +
itostr((int)(EndStr-$3)) +
" when array has size " + itostr(NumElements) + "!");
- vector<ConstPoolVal*> Vals;
+ vector<Constant*> Vals;
if (ETy == Type::SByteTy) {
for (char *C = $3; C != EndStr; ++C)
- Vals.push_back(ConstPoolSInt::get(ETy, *C));
+ Vals.push_back(ConstantSInt::get(ETy, *C));
} else if (ETy == Type::UByteTy) {
for (char *C = $3; C != EndStr; ++C)
- Vals.push_back(ConstPoolUInt::get(ETy, *C));
+ Vals.push_back(ConstantUInt::get(ETy, *C));
} else {
free($3);
ThrowException("Cannot build string arrays of non byte sized elements!");
}
free($3);
- $$ = ConstPoolArray::get(ATy, Vals);
+ $$ = ConstantArray::get(ATy, Vals);
delete $1;
}
| Types '{' ConstVector '}' {
@@ -945,7 +945,7 @@
(*$1)->getDescription() + "'!");
// FIXME: TODO: Check to see that the constants are compatible with the type
// initializer!
- $$ = ConstPoolStruct::get(STy, *$3);
+ $$ = ConstantStruct::get(STy, *$3);
delete $1; delete $3;
}
| Types NULL_TOK {
@@ -954,7 +954,7 @@
ThrowException("Cannot make null pointer constant with type: '" +
(*$1)->getDescription() + "'!");
- $$ = ConstPoolPointerNull::get(PTy);
+ $$ = ConstantPointerNull::get(PTy);
delete $1;
}
| Types SymbolicValueRef {
@@ -994,29 +994,29 @@
}
GlobalValue *GV = cast<GlobalValue>(V);
- $$ = ConstPoolPointerRef::get(GV);
+ $$ = ConstantPointerRef::get(GV);
delete $1; // Free the type handle
}
ConstVal : SIntType EINT64VAL { // integral constants
- if (!ConstPoolSInt::isValueValidForType($1, $2))
+ if (!ConstantSInt::isValueValidForType($1, $2))
ThrowException("Constant value doesn't fit in type!");
- $$ = ConstPoolSInt::get($1, $2);
+ $$ = ConstantSInt::get($1, $2);
}
| UIntType EUINT64VAL { // integral constants
- if (!ConstPoolUInt::isValueValidForType($1, $2))
+ if (!ConstantUInt::isValueValidForType($1, $2))
ThrowException("Constant value doesn't fit in type!");
- $$ = ConstPoolUInt::get($1, $2);
+ $$ = ConstantUInt::get($1, $2);
}
| BOOL TRUE { // Boolean constants
- $$ = ConstPoolBool::True;
+ $$ = ConstantBool::True;
}
| BOOL FALSE { // Boolean constants
- $$ = ConstPoolBool::False;
+ $$ = ConstantBool::False;
}
| FPType FPVAL { // Float & Double constants
- $$ = ConstPoolFP::get($1, $2);
+ $$ = ConstantFP::get($1, $2);
}
// ConstVector - A list of comma seperated constants.
@@ -1024,7 +1024,7 @@
($$ = $1)->push_back($3);
}
| ConstVal {
- $$ = new vector<ConstPoolVal*>();
+ $$ = new vector<Constant*>();
$$->push_back($1);
}
@@ -1066,7 +1066,7 @@
| ConstPool OptAssign OptInternal GlobalType ConstVal {
const Type *Ty = $5->getType();
// Global declarations appear in Constant Pool
- ConstPoolVal *Initializer = $5;
+ Constant *Initializer = $5;
if (Initializer == 0)
ThrowException("Global value initializer is not a constant!");
@@ -1340,7 +1340,7 @@
cast<BasicBlock>(getVal(Type::LabelTy, $6)));
$$ = S;
- list<pair<ConstPoolVal*, BasicBlock*> >::iterator I = $8->begin(),
+ list<pair<Constant*, BasicBlock*> >::iterator I = $8->begin(),
end = $8->end();
for (; I != end; ++I)
S->dest_push_back(I->first, I->second);
@@ -1403,15 +1403,15 @@
JumpTable : JumpTable IntType ConstValueRef ',' LABEL ValueRef {
$$ = $1;
- ConstPoolVal *V = cast<ConstPoolVal>(getValNonImprovising($2, $3));
+ Constant *V = cast<Constant>(getValNonImprovising($2, $3));
if (V == 0)
ThrowException("May only switch on a constant pool value!");
$$->push_back(make_pair(V, cast<BasicBlock>(getVal($5, $6))));
}
| IntType ConstValueRef ',' LABEL ValueRef {
- $$ = new list<pair<ConstPoolVal*, BasicBlock*> >();
- ConstPoolVal *V = cast<ConstPoolVal>(getValNonImprovising($1, $2));
+ $$ = new list<pair<Constant*, BasicBlock*> >();
+ Constant *V = cast<Constant>(getValNonImprovising($1, $2));
if (V == 0)
ThrowException("May only switch on a constant pool value!");