[llvm-commits] CVS: llvm/lib/VMCore/Constants.cpp

[Chris Lattner]

Changes in directory llvm/lib/VMCore:

Constants.cpp updated: 1.128 -> 1.129
---
Log message:

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.

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.


---
Diffs of the changes:  (+14 -10)

 Constants.cpp |   24 ++++++++++++++----------
 1 files changed, 14 insertions(+), 10 deletions(-)


Index: llvm/lib/VMCore/Constants.cpp
diff -u llvm/lib/VMCore/Constants.cpp:1.128 llvm/lib/VMCore/Constants.cpp:1.129
--- llvm/lib/VMCore/Constants.cpp:1.128	Wed Aug 17 15:06:22 2005
+++ llvm/lib/VMCore/Constants.cpp	Tue Sep 27 01:09:08 2005
@@ -209,38 +209,42 @@
 //===----------------------------------------------------------------------===//
 //                             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 @@
 
 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 @@
 
 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() ||