RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-12 05:56:28 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Split SimpleConstantVal up into its components, so each Constant subclass getsa different enum value. This allows 'classof' for these to be really simple,not needing to call getType() anymore.

Browse Source 
This speeds up isa/dyncast/etc for constants, and also makes them smaller.
For example, the text section of a release build of InstCombine.cpp shrinks
from 230037 bytes to 216363 bytes, a 6% reduction.

llvm-svn: 23467
This commit is contained in:
Chris Lattner 2005-09-27 06:09:08 +00:00
parent 92616caa1a
commit 20786460b5
1 changed files with 14 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
lib/VMCore/Constants.cpp
View File

@ -209,38 +209,42 @@ bool ConstantUInt::isAllOnesValue() const {
//===----------------------------------------------------------------------===//
// Normal Constructors
ConstantIntegral::ConstantIntegral(const Type *Ty, uint64_t V)
: Constant(Ty, SimpleConstantVal, 0, 0) {
ConstantIntegral::ConstantIntegral(const Type *Ty, ValueTy VT, uint64_t V)
: Constant(Ty, VT, 0, 0) {
Val.Unsigned = V;
}
ConstantBool::ConstantBool(bool V) : ConstantIntegral(Type::BoolTy, V) {
ConstantBool::ConstantBool(bool V)
: ConstantIntegral(Type::BoolTy, ConstantBoolVal, V) {
}
ConstantInt::ConstantInt(const Type *Ty, uint64_t V) : ConstantIntegral(Ty, V) {
ConstantInt::ConstantInt(const Type *Ty, ValueTy VT, uint64_t V)
: ConstantIntegral(Ty, VT, V) {
}
ConstantSInt::ConstantSInt(const Type *Ty, int64_t V) : ConstantInt(Ty, V) {
ConstantSInt::ConstantSInt(const Type *Ty, int64_t V)
: ConstantInt(Ty, ConstantSIntVal, V) {
assert(Ty->isInteger() && Ty->isSigned() &&
"Illegal type for signed integer constant!");
assert(isValueValidForType(Ty, V) && "Value too large for type!");
}
ConstantUInt::ConstantUInt(const Type *Ty, uint64_t V) : ConstantInt(Ty, V) {
ConstantUInt::ConstantUInt(const Type *Ty, uint64_t V)
: ConstantInt(Ty, ConstantUIntVal, V) {
assert(Ty->isInteger() && Ty->isUnsigned() &&
"Illegal type for unsigned integer constant!");
assert(isValueValidForType(Ty, V) && "Value too large for type!");
}
ConstantFP::ConstantFP(const Type *Ty, double V)
: Constant(Ty, SimpleConstantVal, 0, 0) {
: Constant(Ty, ConstantFPVal, 0, 0) {
assert(isValueValidForType(Ty, V) && "Value too large for type!");
Val = V;
}
ConstantArray::ConstantArray(const ArrayType *T,
const std::vector<Constant*> &V)
: Constant(T, SimpleConstantVal, new Use[V.size()], V.size()) {
: Constant(T, ConstantArrayVal, new Use[V.size()], V.size()) {
assert(V.size() == T->getNumElements() &&
"Invalid initializer vector for constant array");
Use *OL = OperandList;
@ -259,7 +263,7 @@ ConstantArray::~ConstantArray() {
ConstantStruct::ConstantStruct(const StructType *T,
const std::vector<Constant*> &V)
: Constant(T, SimpleConstantVal, new Use[V.size()], V.size()) {
: Constant(T, ConstantStructVal, new Use[V.size()], V.size()) {
assert(V.size() == T->getNumElements() &&
"Invalid initializer vector for constant structure");
Use *OL = OperandList;
@ -280,7 +284,7 @@ ConstantStruct::~ConstantStruct() {
ConstantPacked::ConstantPacked(const PackedType *T,
const std::vector<Constant*> &V)
: Constant(T, SimpleConstantVal, new Use[V.size()], V.size()) {
: Constant(T, ConstantPackedVal, new Use[V.size()], V.size()) {
Use *OL = OperandList;
for (unsigned i = 0, e = V.size(); i != e; ++i) {
assert((V[i]->getType() == T->getElementType() ||