[llvm-commits] CVS: llvm/lib/VMCore/AsmWriter.cpp ConstantFolding.cpp Constants.cpp Instructions.cpp Type.cpp Verifier.cpp

Chris Lattner sabre at nondot.org
Sun Jan 14 18:28:13 PST 2007



Changes in directory llvm/lib/VMCore:

AsmWriter.cpp updated: 1.252 -> 1.253
ConstantFolding.cpp updated: 1.131 -> 1.132
Constants.cpp updated: 1.200 -> 1.201
Instructions.cpp updated: 1.62 -> 1.63
Type.cpp updated: 1.160 -> 1.161
Verifier.cpp updated: 1.185 -> 1.186
---
Log message:

rename Type::isIntegral to Type::isInteger, eliminating the old Type::isInteger.
rename Type::getIntegralTypeMask to Type::getIntegerTypeMask.

This makes naming much more consistent.  For example, there are now no longer any
instances of IntegerType that are not considered isInteger! :)



---
Diffs of the changes:  (+85 -85)

 AsmWriter.cpp       |    6 ++--
 ConstantFolding.cpp |   14 +++++------
 Constants.cpp       |   48 ++++++++++++++++++-------------------
 Instructions.cpp    |   66 ++++++++++++++++++++++++++--------------------------
 Type.cpp            |    2 -
 Verifier.cpp        |   34 +++++++++++++-------------
 6 files changed, 85 insertions(+), 85 deletions(-)


Index: llvm/lib/VMCore/AsmWriter.cpp
diff -u llvm/lib/VMCore/AsmWriter.cpp:1.252 llvm/lib/VMCore/AsmWriter.cpp:1.253
--- llvm/lib/VMCore/AsmWriter.cpp:1.252	Fri Jan 12 13:20:47 2007
+++ llvm/lib/VMCore/AsmWriter.cpp	Sun Jan 14 20:27:26 2007
@@ -222,7 +222,7 @@
     const Type *Ty = cast<Type>(TI->second);
     if (!isa<PointerType>(Ty) ||
         !cast<PointerType>(Ty)->getElementType()->isPrimitiveType() ||
-        !cast<PointerType>(Ty)->getElementType()->isIntegral() ||
+        !cast<PointerType>(Ty)->getElementType()->isInteger() ||
         isa<OpaqueType>(cast<PointerType>(Ty)->getElementType()))
       TypeNames.insert(std::make_pair(Ty, getLLVMName(TI->first)));
   }
@@ -234,7 +234,7 @@
                          std::vector<const Type *> &TypeStack,
                          std::map<const Type *, std::string> &TypeNames,
                          std::string & Result){
-  if (Ty->isIntegral() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) {
+  if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty))) {
     Result += Ty->getDescription();  // Base case
     return;
   }
@@ -353,7 +353,7 @@
   // Primitive types always print out their description, regardless of whether
   // they have been named or not.
   //
-  if (Ty->isIntegral() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)))
+  if (Ty->isInteger() || (Ty->isPrimitiveType() && !isa<OpaqueType>(Ty)))
     return Out << Ty->getDescription();
 
   // Check to see if the type is named.


Index: llvm/lib/VMCore/ConstantFolding.cpp
diff -u llvm/lib/VMCore/ConstantFolding.cpp:1.131 llvm/lib/VMCore/ConstantFolding.cpp:1.132
--- llvm/lib/VMCore/ConstantFolding.cpp:1.131	Fri Jan 12 12:42:52 2007
+++ llvm/lib/VMCore/ConstantFolding.cpp	Sun Jan 14 20:27:26 2007
@@ -51,7 +51,7 @@
     
     // If the src and dest elements are both integers, or both floats, we can 
     // just BitCast each element because the elements are the same size.
-    if ((SrcEltTy->isIntegral() && DstEltTy->isIntegral()) ||
+    if ((SrcEltTy->isInteger() && DstEltTy->isInteger()) ||
         (SrcEltTy->isFloatingPoint() && DstEltTy->isFloatingPoint())) {
       for (unsigned i = 0; i != SrcNumElts; ++i)
         Result.push_back(
@@ -60,7 +60,7 @@
     }
     
     // If this is an int-to-fp cast ..
-    if (SrcEltTy->isIntegral()) {
+    if (SrcEltTy->isInteger()) {
       // Ensure that it is int-to-fp cast
       assert(DstEltTy->isFloatingPoint());
       if (DstEltTy->getTypeID() == Type::DoubleTyID) {
@@ -81,7 +81,7 @@
     }
     
     // Otherwise, this is an fp-to-int cast.
-    assert(SrcEltTy->isFloatingPoint() && DstEltTy->isIntegral());
+    assert(SrcEltTy->isFloatingPoint() && DstEltTy->isInteger());
     
     if (SrcEltTy->getTypeID() == Type::DoubleTyID) {
       for (unsigned i = 0; i != SrcNumElts; ++i) {
@@ -279,7 +279,7 @@
     // Handle integral constant input.
     if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
       // Integral -> Integral, must be changing sign.
-      if (DestTy->isIntegral())
+      if (DestTy->isInteger())
         return ConstantInt::get(DestTy, CI->getZExtValue());
 
       if (DestTy->isFloatingPoint()) {
@@ -295,7 +295,7 @@
     // Handle ConstantFP input.
     if (const ConstantFP *FP = dyn_cast<ConstantFP>(V)) {
       // FP -> Integral.
-      if (DestTy->isIntegral()) {
+      if (DestTy->isInteger()) {
         if (DestTy == Type::Int32Ty)
           return ConstantInt::get(DestTy, FloatToBits(FP->getValue()));
         assert(DestTy == Type::Int64Ty && 
@@ -884,7 +884,7 @@
       // If the cast is not actually changing bits, and the second operand is a
       // null pointer, do the comparison with the pre-casted value.
       if (V2->isNullValue() &&
-          (isa<PointerType>(CE1->getType()) || CE1->getType()->isIntegral())) {
+          (isa<PointerType>(CE1->getType()) || CE1->getType()->isInteger())) {
         bool sgnd = CE1->getOpcode() == Instruction::ZExt ? false :
           (CE1->getOpcode() == Instruction::SExt ? true :
            (CE1->getOpcode() == Instruction::PtrToInt ? false : isSigned));
@@ -899,7 +899,7 @@
       if (const ConstantExpr *CE2 = dyn_cast<ConstantExpr>(V2))
         if (CE2->isCast() && isa<PointerType>(CE1->getType()) &&
             CE1->getOperand(0)->getType() == CE2->getOperand(0)->getType() &&
-            CE1->getOperand(0)->getType()->isIntegral()) {
+            CE1->getOperand(0)->getType()->isInteger()) {
           bool sgnd = CE1->getOpcode() == Instruction::ZExt ? false :
             (CE1->getOpcode() == Instruction::SExt ? true :
              (CE1->getOpcode() == Instruction::PtrToInt ? false : isSigned));


Index: llvm/lib/VMCore/Constants.cpp
diff -u llvm/lib/VMCore/Constants.cpp:1.200 llvm/lib/VMCore/Constants.cpp:1.201
--- llvm/lib/VMCore/Constants.cpp:1.200	Sun Jan 14 18:45:50 2007
+++ llvm/lib/VMCore/Constants.cpp	Sun Jan 14 20:27:26 2007
@@ -849,7 +849,7 @@
       return getTrue();
     else
       return getFalse();
-  return IntConstants->getOrCreate(Ty, V & Ty->getIntegralTypeMask());
+  return IntConstants->getOrCreate(Ty, V & Ty->getIntegerTypeMask());
 }
 
 //---- ConstantFP::get() implementation...
@@ -1463,16 +1463,16 @@
 
 Constant *ConstantExpr::getPointerCast(Constant *S, const Type *Ty) {
   assert(isa<PointerType>(S->getType()) && "Invalid cast");
-  assert((Ty->isIntegral() || isa<PointerType>(Ty)) && "Invalid cast");
+  assert((Ty->isInteger() || isa<PointerType>(Ty)) && "Invalid cast");
 
-  if (Ty->isIntegral())
+  if (Ty->isInteger())
     return getCast(Instruction::PtrToInt, S, Ty);
   return getCast(Instruction::BitCast, S, Ty);
 }
 
 Constant *ConstantExpr::getIntegerCast(Constant *C, const Type *Ty, 
                                        bool isSigned) {
-  assert(C->getType()->isIntegral() && Ty->isIntegral() && "Invalid cast");
+  assert(C->getType()->isInteger() && Ty->isInteger() && "Invalid cast");
   unsigned SrcBits = C->getType()->getPrimitiveSizeInBits();
   unsigned DstBits = Ty->getPrimitiveSizeInBits();
   Instruction::CastOps opcode =
@@ -1495,8 +1495,8 @@
 }
 
 Constant *ConstantExpr::getTrunc(Constant *C, const Type *Ty) {
-  assert(C->getType()->isIntegral() && "Trunc operand must be integer");
-  assert(Ty->isIntegral() && "Trunc produces only integral");
+  assert(C->getType()->isInteger() && "Trunc operand must be integer");
+  assert(Ty->isInteger() && "Trunc produces only integral");
   assert(C->getType()->getPrimitiveSizeInBits() > Ty->getPrimitiveSizeInBits()&&
          "SrcTy must be larger than DestTy for Trunc!");
 
@@ -1504,8 +1504,8 @@
 }
 
 Constant *ConstantExpr::getSExt(Constant *C, const Type *Ty) {
-  assert(C->getType()->isIntegral() && "SEXt operand must be integral");
-  assert(Ty->isIntegral() && "SExt produces only integer");
+  assert(C->getType()->isInteger() && "SEXt operand must be integral");
+  assert(Ty->isInteger() && "SExt produces only integer");
   assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
          "SrcTy must be smaller than DestTy for SExt!");
 
@@ -1513,8 +1513,8 @@
 }
 
 Constant *ConstantExpr::getZExt(Constant *C, const Type *Ty) {
-  assert(C->getType()->isIntegral() && "ZEXt operand must be integral");
-  assert(Ty->isIntegral() && "ZExt produces only integer");
+  assert(C->getType()->isInteger() && "ZEXt operand must be integral");
+  assert(Ty->isInteger() && "ZExt produces only integer");
   assert(C->getType()->getPrimitiveSizeInBits() < Ty->getPrimitiveSizeInBits()&&
          "SrcTy must be smaller than DestTy for ZExt!");
 
@@ -1536,37 +1536,37 @@
 }
 
 Constant *ConstantExpr::getUIToFP(Constant *C, const Type *Ty) {
-  assert(C->getType()->isIntegral() && Ty->isFloatingPoint() &&
+  assert(C->getType()->isInteger() && Ty->isFloatingPoint() &&
          "This is an illegal uint to floating point cast!");
   return getFoldedCast(Instruction::UIToFP, C, Ty);
 }
 
 Constant *ConstantExpr::getSIToFP(Constant *C, const Type *Ty) {
-  assert(C->getType()->isIntegral() && Ty->isFloatingPoint() &&
+  assert(C->getType()->isInteger() && Ty->isFloatingPoint() &&
          "This is an illegal sint to floating point cast!");
   return getFoldedCast(Instruction::SIToFP, C, Ty);
 }
 
 Constant *ConstantExpr::getFPToUI(Constant *C, const Type *Ty) {
-  assert(C->getType()->isFloatingPoint() && Ty->isIntegral() &&
+  assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
          "This is an illegal floating point to uint cast!");
   return getFoldedCast(Instruction::FPToUI, C, Ty);
 }
 
 Constant *ConstantExpr::getFPToSI(Constant *C, const Type *Ty) {
-  assert(C->getType()->isFloatingPoint() && Ty->isIntegral() &&
+  assert(C->getType()->isFloatingPoint() && Ty->isInteger() &&
          "This is an illegal floating point to sint cast!");
   return getFoldedCast(Instruction::FPToSI, C, Ty);
 }
 
 Constant *ConstantExpr::getPtrToInt(Constant *C, const Type *DstTy) {
   assert(isa<PointerType>(C->getType()) && "PtrToInt source must be pointer");
-  assert(DstTy->isIntegral() && "PtrToInt destination must be integral");
+  assert(DstTy->isInteger() && "PtrToInt destination must be integral");
   return getFoldedCast(Instruction::PtrToInt, C, DstTy);
 }
 
 Constant *ConstantExpr::getIntToPtr(Constant *C, const Type *DstTy) {
-  assert(C->getType()->isIntegral() && "IntToPtr source must be integral");
+  assert(C->getType()->isInteger() && "IntToPtr source must be integral");
   assert(isa<PointerType>(DstTy) && "IntToPtr destination must be a pointer");
   return getFoldedCast(Instruction::IntToPtr, C, DstTy);
 }
@@ -1649,15 +1649,15 @@
   case Instruction::Sub:
   case Instruction::Mul: 
     assert(C1->getType() == C2->getType() && "Op types should be identical!");
-    assert((C1->getType()->isIntegral() || C1->getType()->isFloatingPoint() ||
+    assert((C1->getType()->isInteger() || C1->getType()->isFloatingPoint() ||
             isa<PackedType>(C1->getType())) &&
            "Tried to create an arithmetic operation on a non-arithmetic type!");
     break;
   case Instruction::UDiv: 
   case Instruction::SDiv: 
     assert(C1->getType() == C2->getType() && "Op types should be identical!");
-    assert((C1->getType()->isIntegral() || (isa<PackedType>(C1->getType()) &&
-      cast<PackedType>(C1->getType())->getElementType()->isIntegral())) &&
+    assert((C1->getType()->isInteger() || (isa<PackedType>(C1->getType()) &&
+      cast<PackedType>(C1->getType())->getElementType()->isInteger())) &&
            "Tried to create an arithmetic operation on a non-arithmetic type!");
     break;
   case Instruction::FDiv:
@@ -1669,8 +1669,8 @@
   case Instruction::URem: 
   case Instruction::SRem: 
     assert(C1->getType() == C2->getType() && "Op types should be identical!");
-    assert((C1->getType()->isIntegral() || (isa<PackedType>(C1->getType()) &&
-      cast<PackedType>(C1->getType())->getElementType()->isIntegral())) &&
+    assert((C1->getType()->isInteger() || (isa<PackedType>(C1->getType()) &&
+      cast<PackedType>(C1->getType())->getElementType()->isInteger())) &&
            "Tried to create an arithmetic operation on a non-arithmetic type!");
     break;
   case Instruction::FRem:
@@ -1683,14 +1683,14 @@
   case Instruction::Or:
   case Instruction::Xor:
     assert(C1->getType() == C2->getType() && "Op types should be identical!");
-    assert((C1->getType()->isIntegral() || isa<PackedType>(C1->getType())) &&
+    assert((C1->getType()->isInteger() || isa<PackedType>(C1->getType())) &&
            "Tried to create a logical operation on a non-integral type!");
     break;
   case Instruction::Shl:
   case Instruction::LShr:
   case Instruction::AShr:
     assert(C2->getType() == Type::Int8Ty && "Shift should be by ubyte!");
-    assert(C1->getType()->isIntegral() &&
+    assert(C1->getType()->isInteger() &&
            "Tried to create a shift operation on a non-integer type!");
     break;
   default:
@@ -1732,7 +1732,7 @@
           Opcode == Instruction::LShr  ||
           Opcode == Instruction::AShr) &&
          "Invalid opcode in binary constant expression");
-  assert(C1->getType()->isIntegral() && C2->getType() == Type::Int8Ty &&
+  assert(C1->getType()->isInteger() && C2->getType() == Type::Int8Ty &&
          "Invalid operand types for Shift constant expr!");
 
   if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2))


Index: llvm/lib/VMCore/Instructions.cpp
diff -u llvm/lib/VMCore/Instructions.cpp:1.62 llvm/lib/VMCore/Instructions.cpp:1.63
--- llvm/lib/VMCore/Instructions.cpp:1.62	Sun Jan 14 20:05:34 2007
+++ llvm/lib/VMCore/Instructions.cpp	Sun Jan 14 20:27:26 2007
@@ -1025,7 +1025,7 @@
   case Mul: 
     assert(getType() == LHS->getType() &&
            "Arithmetic operation should return same type as operands!");
-    assert((getType()->isIntegral() || getType()->isFloatingPoint() ||
+    assert((getType()->isInteger() || getType()->isFloatingPoint() ||
             isa<PackedType>(getType())) &&
           "Tried to create an arithmetic operation on a non-arithmetic type!");
     break;
@@ -1033,8 +1033,8 @@
   case SDiv: 
     assert(getType() == LHS->getType() &&
            "Arithmetic operation should return same type as operands!");
-    assert((getType()->isIntegral() || (isa<PackedType>(getType()) && 
-            cast<PackedType>(getType())->getElementType()->isIntegral())) &&
+    assert((getType()->isInteger() || (isa<PackedType>(getType()) && 
+            cast<PackedType>(getType())->getElementType()->isInteger())) &&
            "Incorrect operand type (not integer) for S/UDIV");
     break;
   case FDiv:
@@ -1048,8 +1048,8 @@
   case SRem: 
     assert(getType() == LHS->getType() &&
            "Arithmetic operation should return same type as operands!");
-    assert((getType()->isIntegral() || (isa<PackedType>(getType()) && 
-            cast<PackedType>(getType())->getElementType()->isIntegral())) &&
+    assert((getType()->isInteger() || (isa<PackedType>(getType()) && 
+            cast<PackedType>(getType())->getElementType()->isInteger())) &&
            "Incorrect operand type (not integer) for S/UREM");
     break;
   case FRem:
@@ -1063,9 +1063,9 @@
   case Xor:
     assert(getType() == LHS->getType() &&
            "Logical operation should return same type as operands!");
-    assert((getType()->isIntegral() ||
+    assert((getType()->isInteger() ||
             (isa<PackedType>(getType()) && 
-             cast<PackedType>(getType())->getElementType()->isIntegral())) &&
+             cast<PackedType>(getType())->getElementType()->isInteger())) &&
            "Tried to create a logical operation on a non-integral type!");
     break;
   default:
@@ -1218,7 +1218,7 @@
     case Instruction::Trunc:
       return true;
     case Instruction::BitCast:
-      return getOperand(0)->getType()->isIntegral() && getType()->isIntegral();
+      return getOperand(0)->getType()->isInteger() && getType()->isInteger();
   }
 }
 
@@ -1351,7 +1351,7 @@
     case 3: 
       // no-op cast in second op implies firstOp as long as the DestTy 
       // is integer
-      if (DstTy->isIntegral())
+      if (DstTy->isInteger())
         return firstOp;
       return 0;
     case 4:
@@ -1363,7 +1363,7 @@
     case 5: 
       // no-op cast in first op implies secondOp as long as the SrcTy
       // is an integer
-      if (SrcTy->isIntegral())
+      if (SrcTy->isInteger())
         return secondOp;
       return 0;
     case 6:
@@ -1528,10 +1528,10 @@
                                       const std::string &Name,
                                       BasicBlock *InsertAtEnd) {
   assert(isa<PointerType>(S->getType()) && "Invalid cast");
-  assert((Ty->isIntegral() || isa<PointerType>(Ty)) &&
+  assert((Ty->isInteger() || isa<PointerType>(Ty)) &&
          "Invalid cast");
 
-  if (Ty->isIntegral())
+  if (Ty->isInteger())
     return create(Instruction::PtrToInt, S, Ty, Name, InsertAtEnd);
   return create(Instruction::BitCast, S, Ty, Name, InsertAtEnd);
 }
@@ -1541,10 +1541,10 @@
                                       const std::string &Name, 
                                       Instruction *InsertBefore) {
   assert(isa<PointerType>(S->getType()) && "Invalid cast");
-  assert((Ty->isIntegral() || isa<PointerType>(Ty)) &&
+  assert((Ty->isInteger() || isa<PointerType>(Ty)) &&
          "Invalid cast");
 
-  if (Ty->isIntegral())
+  if (Ty->isInteger())
     return create(Instruction::PtrToInt, S, Ty, Name, InsertBefore);
   return create(Instruction::BitCast, S, Ty, Name, InsertBefore);
 }
@@ -1552,7 +1552,7 @@
 CastInst *CastInst::createIntegerCast(Value *C, const Type *Ty, 
                                       bool isSigned, const std::string &Name,
                                       Instruction *InsertBefore) {
-  assert(C->getType()->isIntegral() && Ty->isIntegral() && "Invalid cast");
+  assert(C->getType()->isInteger() && Ty->isInteger() && "Invalid cast");
   unsigned SrcBits = C->getType()->getPrimitiveSizeInBits();
   unsigned DstBits = Ty->getPrimitiveSizeInBits();
   Instruction::CastOps opcode =
@@ -1565,7 +1565,7 @@
 CastInst *CastInst::createIntegerCast(Value *C, const Type *Ty, 
                                       bool isSigned, const std::string &Name,
                                       BasicBlock *InsertAtEnd) {
-  assert(C->getType()->isIntegral() && Ty->isIntegral() && "Invalid cast");
+  assert(C->getType()->isInteger() && Ty->isInteger() && "Invalid cast");
   unsigned SrcBits = C->getType()->getPrimitiveSizeInBits();
   unsigned DstBits = Ty->getPrimitiveSizeInBits();
   Instruction::CastOps opcode =
@@ -1616,8 +1616,8 @@
   unsigned DestBits = DestTy->getPrimitiveSizeInBits(); // 0 for ptr/packed
 
   // Run through the possibilities ...
-  if (DestTy->isIntegral()) {                       // Casting to integral
-    if (SrcTy->isIntegral()) {                      // Casting from integral
+  if (DestTy->isInteger()) {                       // Casting to integral
+    if (SrcTy->isInteger()) {                      // Casting from integral
       if (DestBits < SrcBits)
         return Trunc;                               // int -> smaller int
       else if (DestBits > SrcBits) {                // its an extension
@@ -1643,7 +1643,7 @@
       return PtrToInt;                              // ptr -> int
     }
   } else if (DestTy->isFloatingPoint()) {           // Casting to floating pt
-    if (SrcTy->isIntegral()) {                      // Casting from integral
+    if (SrcTy->isInteger()) {                      // Casting from integral
       if (SrcIsSigned)
         return SIToFP;                              // sint -> FP
       else
@@ -1676,7 +1676,7 @@
   } else if (isa<PointerType>(DestTy)) {
     if (isa<PointerType>(SrcTy)) {
       return BitCast;                               // ptr -> ptr
-    } else if (SrcTy->isIntegral()) {
+    } else if (SrcTy->isInteger()) {
       return IntToPtr;                              // int -> ptr
     } else {
       assert(!"Casting pointer to other than pointer or int");
@@ -1715,11 +1715,11 @@
   switch (op) {
   default: return false; // This is an input error
   case Instruction::Trunc:
-    return SrcTy->isIntegral() && DstTy->isIntegral()&& SrcBitSize > DstBitSize;
+    return SrcTy->isInteger() && DstTy->isInteger()&& SrcBitSize > DstBitSize;
   case Instruction::ZExt:
-    return SrcTy->isIntegral() && DstTy->isIntegral()&& SrcBitSize < DstBitSize;
+    return SrcTy->isInteger() && DstTy->isInteger()&& SrcBitSize < DstBitSize;
   case Instruction::SExt: 
-    return SrcTy->isIntegral() && DstTy->isIntegral()&& SrcBitSize < DstBitSize;
+    return SrcTy->isInteger() && DstTy->isInteger()&& SrcBitSize < DstBitSize;
   case Instruction::FPTrunc:
     return SrcTy->isFloatingPoint() && DstTy->isFloatingPoint() && 
       SrcBitSize > DstBitSize;
@@ -1727,17 +1727,17 @@
     return SrcTy->isFloatingPoint() && DstTy->isFloatingPoint() && 
       SrcBitSize < DstBitSize;
   case Instruction::UIToFP:
-    return SrcTy->isIntegral() && DstTy->isFloatingPoint();
+    return SrcTy->isInteger() && DstTy->isFloatingPoint();
   case Instruction::SIToFP:
-    return SrcTy->isIntegral() && DstTy->isFloatingPoint();
+    return SrcTy->isInteger() && DstTy->isFloatingPoint();
   case Instruction::FPToUI:
-    return SrcTy->isFloatingPoint() && DstTy->isIntegral();
+    return SrcTy->isFloatingPoint() && DstTy->isInteger();
   case Instruction::FPToSI:
-    return SrcTy->isFloatingPoint() && DstTy->isIntegral();
+    return SrcTy->isFloatingPoint() && DstTy->isInteger();
   case Instruction::PtrToInt:
-    return isa<PointerType>(SrcTy) && DstTy->isIntegral();
+    return isa<PointerType>(SrcTy) && DstTy->isInteger();
   case Instruction::IntToPtr:
-    return SrcTy->isIntegral() && isa<PointerType>(DstTy);
+    return SrcTy->isInteger() && isa<PointerType>(DstTy);
   case Instruction::BitCast:
     // BitCast implies a no-op cast of type only. No bits change.
     // However, you can't cast pointers to anything but pointers.
@@ -1913,9 +1913,9 @@
     assert(Op0Ty == Op1Ty &&
            "Both operands to ICmp instruction are not of the same type!");
     // Check that the operands are the right type
-    assert(Op0Ty->isIntegral() || isa<PointerType>(Op0Ty) ||
+    assert(Op0Ty->isInteger() || isa<PointerType>(Op0Ty) ||
            (isa<PackedType>(Op0Ty) && 
-            cast<PackedType>(Op0Ty)->getElementType()->isIntegral()) &&
+            cast<PackedType>(Op0Ty)->getElementType()->isInteger()) &&
            "Invalid operand types for ICmp instruction");
     return;
   }
@@ -1948,9 +1948,9 @@
     assert(Op0Ty == Op1Ty &&
           "Both operands to ICmp instruction are not of the same type!");
     // Check that the operands are the right type
-    assert(Op0Ty->isIntegral() || isa<PointerType>(Op0Ty) ||
+    assert(Op0Ty->isInteger() || isa<PointerType>(Op0Ty) ||
            (isa<PackedType>(Op0Ty) && 
-            cast<PackedType>(Op0Ty)->getElementType()->isIntegral()) &&
+            cast<PackedType>(Op0Ty)->getElementType()->isInteger()) &&
            "Invalid operand types for ICmp instruction");
     return;
   }


Index: llvm/lib/VMCore/Type.cpp
diff -u llvm/lib/VMCore/Type.cpp:1.160 llvm/lib/VMCore/Type.cpp:1.161
--- llvm/lib/VMCore/Type.cpp:1.160	Fri Jan 12 19:09:33 2007
+++ llvm/lib/VMCore/Type.cpp	Sun Jan 14 20:27:26 2007
@@ -428,7 +428,7 @@
   NumElements = NumEl;
 
   assert(NumEl > 0 && "NumEl of a PackedType must be greater than 0");
-  assert((ElType->isIntegral() || ElType->isFloatingPoint()) &&
+  assert((ElType->isInteger() || ElType->isFloatingPoint()) &&
          "Elements of a PackedType must be a primitive type");
 }
 


Index: llvm/lib/VMCore/Verifier.cpp
diff -u llvm/lib/VMCore/Verifier.cpp:1.185 llvm/lib/VMCore/Verifier.cpp:1.186
--- llvm/lib/VMCore/Verifier.cpp:1.185	Sun Jan 14 20:05:34 2007
+++ llvm/lib/VMCore/Verifier.cpp	Sun Jan 14 20:27:26 2007
@@ -500,8 +500,8 @@
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
-  Assert1(SrcTy->isIntegral(), "Trunc only operates on integer", &I);
-  Assert1(DestTy->isIntegral(), "Trunc only produces integer", &I);
+  Assert1(SrcTy->isInteger(), "Trunc only operates on integer", &I);
+  Assert1(DestTy->isInteger(), "Trunc only produces integer", &I);
   Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I);
 
   visitInstruction(I);
@@ -513,8 +513,8 @@
   const Type *DestTy = I.getType();
 
   // Get the size of the types in bits, we'll need this later
-  Assert1(SrcTy->isIntegral(), "ZExt only operates on integer", &I);
-  Assert1(DestTy->isIntegral(), "ZExt only produces an integer", &I);
+  Assert1(SrcTy->isInteger(), "ZExt only operates on integer", &I);
+  Assert1(DestTy->isInteger(), "ZExt only produces an integer", &I);
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
@@ -532,8 +532,8 @@
   unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
   unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
 
-  Assert1(SrcTy->isIntegral(), "SExt only operates on integer", &I);
-  Assert1(DestTy->isIntegral(), "SExt only produces an integer", &I);
+  Assert1(SrcTy->isInteger(), "SExt only operates on integer", &I);
+  Assert1(DestTy->isInteger(), "SExt only produces an integer", &I);
   Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I);
 
   visitInstruction(I);
@@ -575,7 +575,7 @@
   const Type *SrcTy = I.getOperand(0)->getType();
   const Type *DestTy = I.getType();
 
-  Assert1(SrcTy->isIntegral(),"UInt2FP source must be integral", &I);
+  Assert1(SrcTy->isInteger(),"UInt2FP source must be integral", &I);
   Assert1(DestTy->isFloatingPoint(),"UInt2FP result must be FP", &I);
 
   visitInstruction(I);
@@ -586,7 +586,7 @@
   const Type *SrcTy = I.getOperand(0)->getType();
   const Type *DestTy = I.getType();
 
-  Assert1(SrcTy->isIntegral(),"SInt2FP source must be integral", &I);
+  Assert1(SrcTy->isInteger(),"SInt2FP source must be integral", &I);
   Assert1(DestTy->isFloatingPoint(),"SInt2FP result must be FP", &I);
 
   visitInstruction(I);
@@ -598,7 +598,7 @@
   const Type *DestTy = I.getType();
 
   Assert1(SrcTy->isFloatingPoint(),"FP2UInt source must be FP", &I);
-  Assert1(DestTy->isIntegral(),"FP2UInt result must be integral", &I);
+  Assert1(DestTy->isInteger(),"FP2UInt result must be integral", &I);
 
   visitInstruction(I);
 }
@@ -609,7 +609,7 @@
   const Type *DestTy = I.getType();
 
   Assert1(SrcTy->isFloatingPoint(),"FPToSI source must be FP", &I);
-  Assert1(DestTy->isIntegral(),"FP2ToI result must be integral", &I);
+  Assert1(DestTy->isInteger(),"FP2ToI result must be integral", &I);
 
   visitInstruction(I);
 }
@@ -620,7 +620,7 @@
   const Type *DestTy = I.getType();
 
   Assert1(isa<PointerType>(SrcTy), "PtrToInt source must be pointer", &I);
-  Assert1(DestTy->isIntegral(), "PtrToInt result must be integral", &I);
+  Assert1(DestTy->isInteger(), "PtrToInt result must be integral", &I);
 
   visitInstruction(I);
 }
@@ -630,7 +630,7 @@
   const Type *SrcTy = I.getOperand(0)->getType();
   const Type *DestTy = I.getType();
 
-  Assert1(SrcTy->isIntegral(), "IntToPtr source must be an integral", &I);
+  Assert1(SrcTy->isInteger(), "IntToPtr source must be an integral", &I);
   Assert1(isa<PointerType>(DestTy), "IntToPtr result must be a pointer",&I);
 
   visitInstruction(I);
@@ -716,9 +716,9 @@
   // Check that logical operators are only used with integral operands.
   if (B.getOpcode() == Instruction::And || B.getOpcode() == Instruction::Or ||
       B.getOpcode() == Instruction::Xor) {
-    Assert1(B.getType()->isIntegral() ||
+    Assert1(B.getType()->isInteger() ||
             (isa<PackedType>(B.getType()) && 
-             cast<PackedType>(B.getType())->getElementType()->isIntegral()),
+             cast<PackedType>(B.getType())->getElementType()->isInteger()),
             "Logical operators only work with integral types!", &B);
     Assert1(B.getType() == B.getOperand(0)->getType(),
             "Logical operators must have same type for operands and result!",
@@ -728,7 +728,7 @@
     Assert1(B.getType() == B.getOperand(0)->getType(),
             "Arithmetic operators must have same type for operands and result!",
             &B);
-    Assert1(B.getType()->isIntegral() || B.getType()->isFloatingPoint() ||
+    Assert1(B.getType()->isInteger() || B.getType()->isFloatingPoint() ||
             isa<PackedType>(B.getType()),
             "Arithmetic operators must have integer, fp, or packed type!", &B);
   }
@@ -743,7 +743,7 @@
   Assert1(Op0Ty == Op1Ty,
           "Both operands to ICmp instruction are not of the same type!", &IC);
   // Check that the operands are the right type
-  Assert1(Op0Ty->isIntegral() || isa<PointerType>(Op0Ty),
+  Assert1(Op0Ty->isInteger() || isa<PointerType>(Op0Ty),
           "Invalid operand types for ICmp instruction", &IC);
   visitInstruction(IC);
 }
@@ -761,7 +761,7 @@
 }
 
 void Verifier::visitShiftInst(ShiftInst &SI) {
-  Assert1(SI.getType()->isIntegral(),
+  Assert1(SI.getType()->isInteger(),
           "Shift must return an integer result!", &SI);
   Assert1(SI.getType() == SI.getOperand(0)->getType(),
           "Shift return type must be same as first operand!", &SI);






More information about the llvm-commits mailing list