Simplify code by using ConstantInt::getRawValue instead of checking to see

whether the constant is signed or unsigned, then casting


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@7252 91177308-0d34-0410-b5e6-96231b3b80d8

16 files changed, 44 insertions, 129 deletions

diff --git a/lib/Analysis/ConstantRange.cpp b/lib/Analysis/ConstantRange.cpp
index b7ef5e0511..c9d8ae6fbb 100644
--- a/lib/Analysis/ConstantRange.cpp
+++ b/lib/Analysis/ConstantRange.cpp
@@ -126,10 +126,7 @@ uint64_t ConstantRange::getSetSize() const {
   // Simply subtract the bounds...
   Constant *Result = *(Constant*)Upper - *(Constant*)Lower;
   assert(Result && "Subtraction of constant integers not implemented?");
-  if (getType()->isSigned())
-    return (uint64_t)cast<ConstantSInt>(Result)->getValue();
-  else
-    return cast<ConstantUInt>(Result)->getValue();
+  return cast<ConstantInt>(Result)->getRawValue();
 }
 
 
diff --git a/lib/Support/ConstantRange.cpp b/lib/Support/ConstantRange.cpp
index b7ef5e0511..c9d8ae6fbb 100644
--- a/lib/Support/ConstantRange.cpp
+++ b/lib/Support/ConstantRange.cpp
@@ -126,10 +126,7 @@ uint64_t ConstantRange::getSetSize() const {
   // Simply subtract the bounds...
   Constant *Result = *(Constant*)Upper - *(Constant*)Lower;
   assert(Result && "Subtraction of constant integers not implemented?");
-  if (getType()->isSigned())
-    return (uint64_t)cast<ConstantSInt>(Result)->getValue();
-  else
-    return cast<ConstantUInt>(Result)->getValue();
+  return cast<ConstantInt>(Result)->getRawValue();
 }
 
 
diff --git a/lib/Target/CBackend/CBackend.cpp b/lib/Target/CBackend/CBackend.cpp
index 6d6f145b92..c15c23e369 100644
--- a/lib/Target/CBackend/CBackend.cpp
+++ b/lib/Target/CBackend/CBackend.cpp
@@ -324,9 +324,7 @@ void CWriter::printConstantArray(ConstantArray *CPA) {
 
     // Do not include the last character, which we know is null
     for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
-      unsigned char C = (ETy == Type::SByteTy) ?
-        (unsigned char)cast<ConstantSInt>(CPA->getOperand(i))->getValue() :
-        (unsigned char)cast<ConstantUInt>(CPA->getOperand(i))->getValue();
+      unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getRawValue();
       
       // Print it out literally if it is a printable character.  The only thing
       // to be careful about is when the last letter output was a hex escape
diff --git a/lib/Target/CBackend/Writer.cpp b/lib/Target/CBackend/Writer.cpp
index 6d6f145b92..c15c23e369 100644
--- a/lib/Target/CBackend/Writer.cpp
+++ b/lib/Target/CBackend/Writer.cpp
@@ -324,9 +324,7 @@ void CWriter::printConstantArray(ConstantArray *CPA) {
 
     // Do not include the last character, which we know is null
     for (unsigned i = 0, e = CPA->getNumOperands()-1; i != e; ++i) {
-      unsigned char C = (ETy == Type::SByteTy) ?
-        (unsigned char)cast<ConstantSInt>(CPA->getOperand(i))->getValue() :
-        (unsigned char)cast<ConstantUInt>(CPA->getOperand(i))->getValue();
+      unsigned char C = cast<ConstantInt>(CPA->getOperand(i))->getRawValue();
       
       // Print it out literally if it is a printable character.  The only thing
       // to be careful about is when the last letter output was a hex escape
diff --git a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
index 6080e99e73..019d447e50 100644
--- a/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
+++ b/lib/Target/SparcV9/SparcV9AsmPrinter.cpp
@@ -585,9 +585,7 @@ static string getAsCString(const ConstantArray *CVA) {
   const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
   Result = "\"";
   for (unsigned i = 0; i < CVA->getNumOperands(); ++i) {
-    unsigned char C = (ETy == Type::SByteTy) ?
-      (unsigned char)cast<ConstantSInt>(CVA->getOperand(i))->getValue() :
-      (unsigned char)cast<ConstantUInt>(CVA->getOperand(i))->getValue();
+    unsigned char C = cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
 
     if (C == '"') {
       Result += "\\\"";
diff --git a/lib/Target/SparcV9/SparcV9InstrInfo.cpp b/lib/Target/SparcV9/SparcV9InstrInfo.cpp
index 75bea0d777..39d6dcc6a1 100644
--- a/lib/Target/SparcV9/SparcV9InstrInfo.cpp
+++ b/lib/Target/SparcV9/SparcV9InstrInfo.cpp
@@ -43,10 +43,8 @@ GetConstantValueAsUnsignedInt(const Value *V,
   if (isa<Constant>(V))
     if (const ConstantBool *CB = dyn_cast<ConstantBool>(V))
       return (int64_t)CB->getValue();
-    else if (const ConstantSInt *CS = dyn_cast<ConstantSInt>(V))
-      return (uint64_t)CS->getValue();
-    else if (const ConstantUInt *CU = dyn_cast<ConstantUInt>(V))
-      return CU->getValue();
+    else if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
+      return CI->getRawValue();
 
   isValidConstant = false;
   return 0;
@@ -377,15 +375,11 @@ UltraSparcInstrInfo::ConstantMayNotFitInImmedField(const Constant* CV,
   if (isa<ConstantPointerNull>(CV))               // can always use %g0
     return false;
 
-  if (const ConstantUInt* U = dyn_cast<ConstantUInt>(CV))
-    /* Large unsigned longs may really just be small negative signed longs */
-    return (labs((int64_t) U->getValue()) > MaxConstantsTable[I->getOpcode()]);
-
-  if (const ConstantSInt* S = dyn_cast<ConstantSInt>(CV))
-    return (labs(S->getValue()) > MaxConstantsTable[I->getOpcode()]);
+  if (const ConstantInt* CI = dyn_cast<ConstantInt>(CV))
+    return labs((int64_t)CI->getRawValue()) > MaxConstantsTable[I->getOpcode()];
 
   if (isa<ConstantBool>(CV))
-    return (1 > MaxConstantsTable[I->getOpcode()]);
+    return 1 > MaxConstantsTable[I->getOpcode()];
 
   return true;
 }
diff --git a/lib/Target/X86/InstSelectSimple.cpp b/lib/Target/X86/InstSelectSimple.cpp
index ec8313eda4..1562c8483d 100644
--- a/lib/Target/X86/InstSelectSimple.cpp
+++ b/lib/Target/X86/InstSelectSimple.cpp
@@ -343,12 +343,7 @@ void ISel::copyConstantToRegister(MachineBasicBlock *MBB,
 
     if (Class == cLong) {
       // Copy the value into the register pair.
-      uint64_t Val;
-      if (C->getType()->isSigned())
-	Val = cast<ConstantSInt>(C)->getValue();
-      else
-	Val = cast<ConstantUInt>(C)->getValue();
-
+      uint64_t Val = cast<ConstantInt>(C)->getRawValue();
       BMI(MBB, IP, X86::MOVir32, 1, R).addZImm(Val & 0xFFFFFFFF);
       BMI(MBB, IP, X86::MOVir32, 1, R+1).addZImm(Val >> 32);
       return;
@@ -362,12 +357,9 @@ void ISel::copyConstantToRegister(MachineBasicBlock *MBB,
 
     if (C->getType() == Type::BoolTy) {
       BMI(MBB, IP, X86::MOVir8, 1, R).addZImm(C == ConstantBool::True);
-    } else if (C->getType()->isSigned()) {
-      ConstantSInt *CSI = cast<ConstantSInt>(C);
-      BMI(MBB, IP, IntegralOpcodeTab[Class], 1, R).addZImm(CSI->getValue());
     } else {
-      ConstantUInt *CUI = cast<ConstantUInt>(C);
-      BMI(MBB, IP, IntegralOpcodeTab[Class], 1, R).addZImm(CUI->getValue());
+      ConstantInt *CI = cast<ConstantInt>(C);
+      BMI(MBB, IP, IntegralOpcodeTab[Class], 1, R).addZImm(CI->getRawValue());
     }
   } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
     double Value = CFP->getValue();
@@ -585,11 +577,8 @@ bool ISel::EmitComparisonGetSignedness(unsigned OpNum, Value *Op0, Value *Op1) {
   // Special case handling of: cmp R, i
   if (Class == cByte || Class == cShort || Class == cInt)
     if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
-      uint64_t Op1v;
-      if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI))
-        Op1v = CSI->getValue();
-      else
-        Op1v = cast<ConstantUInt>(CI)->getValue();
+      uint64_t Op1v = cast<ConstantInt>(CI)->getRawValue();
+
       // Mask off any upper bits of the constant, if there are any...
       Op1v &= (1ULL << (8 << Class)) - 1;
 
@@ -1061,11 +1050,7 @@ void ISel::emitSimpleBinaryOperation(MachineBasicBlock *BB,
     assert(Class < 3 && "General code handles 64-bit integer types!");
     unsigned Opcode = OpcodeTab[OperatorClass][Class];
     unsigned Op0r = getReg(Op0, BB, IP);
-    uint64_t Op1v;
-    if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(Op1C))
-      Op1v = CSI->getValue();
-    else
-      Op1v = cast<ConstantUInt>(Op1C)->getValue();
+    uint64_t Op1v = cast<ConstantInt>(Op1C)->getRawValue();
 
     // Mask off any upper bits of the constant, if there are any...
     Op1v &= (1ULL << (8 << Class)) - 1;
@@ -2082,8 +2067,6 @@ void ISel::visitMallocInst(MallocInst &I) {
     unsigned Op1Reg = getReg(I.getOperand(0));
     MachineBasicBlock::iterator MBBI = BB->end();
     doMultiply(BB, MBBI, Arg, Type::UIntTy, Op0Reg, Op1Reg);
-	       
-	       
   }
 
   std::vector<ValueRecord> Args;
diff --git a/lib/Target/X86/Printer.cpp b/lib/Target/X86/Printer.cpp
index c2f2bb8f79..08dbb6c7a5 100644
--- a/lib/Target/X86/Printer.cpp
+++ b/lib/Target/X86/Printer.cpp
@@ -293,9 +293,7 @@ static std::string getAsCString(const ConstantArray *CVA) {
   const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
   Result = "\"";
   for (unsigned i = 0; i < CVA->getNumOperands(); ++i) {
-    unsigned char C = (ETy == Type::SByteTy) ?
-      (unsigned char)cast<ConstantSInt>(CVA->getOperand(i))->getValue() :
-      (unsigned char)cast<ConstantUInt>(CVA->getOperand(i))->getValue();
+    unsigned char C = cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
 
     if (C == '"') {
       Result += "\\\"";
@@ -943,19 +941,14 @@ bool Printer::doInitialization(Module &M)
   return false; // success
 }
 
-static const Function *isConstantFunctionPointerRef (const Constant *C) {
-  const ConstantPointerRef *R = dyn_cast<ConstantPointerRef>(C);
-  if (R) {
-    const Function *F = dyn_cast<Function>(R->getValue());
-    if (F) {
+static const Function *isConstantFunctionPointerRef(const Constant *C) {
+  if (const ConstantPointerRef *R = dyn_cast<ConstantPointerRef>(C))
+    if (const Function *F = dyn_cast<Function>(R->getValue()))
       return F;
-    }
-  }
-  return NULL;
+  return 0;
 }
 
-bool Printer::doFinalization(Module &M)
-{
+bool Printer::doFinalization(Module &M) {
   // Print out module-level global variables here.
   for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I) {
     std::string name(getValueName(I));
@@ -989,5 +982,3 @@ bool Printer::doFinalization(Module &M)
   MangledGlobals.clear();
   return false; // success
 }
-
-
diff --git a/lib/Target/X86/X86AsmPrinter.cpp b/lib/Target/X86/X86AsmPrinter.cpp
index c2f2bb8f79..08dbb6c7a5 100644
--- a/lib/Target/X86/X86AsmPrinter.cpp
+++ b/lib/Target/X86/X86AsmPrinter.cpp
@@ -293,9 +293,7 @@ static std::string getAsCString(const ConstantArray *CVA) {
   const Type *ETy = cast<ArrayType>(CVA->getType())->getElementType();
   Result = "\"";
   for (unsigned i = 0; i < CVA->getNumOperands(); ++i) {
-    unsigned char C = (ETy == Type::SByteTy) ?
-      (unsigned char)cast<ConstantSInt>(CVA->getOperand(i))->getValue() :
-      (unsigned char)cast<ConstantUInt>(CVA->getOperand(i))->getValue();
+    unsigned char C = cast<ConstantInt>(CVA->getOperand(i))->getRawValue();
 
     if (C == '"') {
       Result += "\\\"";
@@ -943,19 +941,14 @@ bool Printer::doInitialization(Module &M)
   return false; // success
 }
 
-static const Function *isConstantFunctionPointerRef (const Constant *C) {
-  const ConstantPointerRef *R = dyn_cast<ConstantPointerRef>(C);
-  if (R) {
-    const Function *F = dyn_cast<Function>(R->getValue());
-    if (F) {
+static const Function *isConstantFunctionPointerRef(const Constant *C) {
+  if (const ConstantPointerRef *R = dyn_cast<ConstantPointerRef>(C))
+    if (const Function *F = dyn_cast<Function>(R->getValue()))
       return F;
-    }
-  }
-  return NULL;
+  return 0;
 }
 
-bool Printer::doFinalization(Module &M)
-{
+bool Printer::doFinalization(Module &M) {
   // Print out module-level global variables here.
   for (Module::const_giterator I = M.gbegin(), E = M.gend(); I != E; ++I) {
     std::string name(getValueName(I));
@@ -989,5 +982,3 @@ bool Printer::doFinalization(Module &M)
   MangledGlobals.clear();
   return false; // success
 }
-
-
diff --git a/lib/Target/X86/X86ISelSimple.cpp b/lib/Target/X86/X86ISelSimple.cpp
index ec8313eda4..1562c8483d 100644
--- a/lib/Target/X86/X86ISelSimple.cpp
+++ b/lib/Target/X86/X86ISelSimple.cpp
@@ -343,12 +343,7 @@ void ISel::copyConstantToRegister(MachineBasicBlock *MBB,
 
     if (Class == cLong) {
       // Copy the value into the register pair.
-      uint64_t Val;
-      if (C->getType()->isSigned())
-	Val = cast<ConstantSInt>(C)->getValue();
-      else
-	Val = cast<ConstantUInt>(C)->getValue();
-
+      uint64_t Val = cast<ConstantInt>(C)->getRawValue();
       BMI(MBB, IP, X86::MOVir32, 1, R).addZImm(Val & 0xFFFFFFFF);
       BMI(MBB, IP, X86::MOVir32, 1, R+1).addZImm(Val >> 32);
       return;
@@ -362,12 +357,9 @@ void ISel::copyConstantToRegister(MachineBasicBlock *MBB,
 
     if (C->getType() == Type::BoolTy) {
       BMI(MBB, IP, X86::MOVir8, 1, R).addZImm(C == ConstantBool::True);
-    } else if (C->getType()->isSigned()) {
-      ConstantSInt *CSI = cast<ConstantSInt>(C);
-      BMI(MBB, IP, IntegralOpcodeTab[Class], 1, R).addZImm(CSI->getValue());
     } else {
-      ConstantUInt *CUI = cast<ConstantUInt>(C);
-      BMI(MBB, IP, IntegralOpcodeTab[Class], 1, R).addZImm(CUI->getValue());
+      ConstantInt *CI = cast<ConstantInt>(C);
+      BMI(MBB, IP, IntegralOpcodeTab[Class], 1, R).addZImm(CI->getRawValue());
     }
   } else if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) {
     double Value = CFP->getValue();
@@ -585,11 +577,8 @@ bool ISel::EmitComparisonGetSignedness(unsigned OpNum, Value *Op0, Value *Op1) {
   // Special case handling of: cmp R, i
   if (Class == cByte || Class == cShort || Class == cInt)
     if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
-      uint64_t Op1v;
-      if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(CI))
-        Op1v = CSI->getValue();
-      else
-        Op1v = cast<ConstantUInt>(CI)->getValue();
+      uint64_t Op1v = cast<ConstantInt>(CI)->getRawValue();
+
       // Mask off any upper bits of the constant, if there are any...
       Op1v &= (1ULL << (8 << Class)) - 1;
 
@@ -1061,11 +1050,7 @@ void ISel::emitSimpleBinaryOperation(MachineBasicBlock *BB,
     assert(Class < 3 && "General code handles 64-bit integer types!");
     unsigned Opcode = OpcodeTab[OperatorClass][Class];
     unsigned Op0r = getReg(Op0, BB, IP);
-    uint64_t Op1v;
-    if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(Op1C))
-      Op1v = CSI->getValue();
-    else
-      Op1v = cast<ConstantUInt>(Op1C)->getValue();
+    uint64_t Op1v = cast<ConstantInt>(Op1C)->getRawValue();
 
     // Mask off any upper bits of the constant, if there are any...
     Op1v &= (1ULL << (8 << Class)) - 1;
@@ -2082,8 +2067,6 @@ void ISel::visitMallocInst(MallocInst &I) {
     unsigned Op1Reg = getReg(I.getOperand(0));
     MachineBasicBlock::iterator MBBI = BB->end();
     doMultiply(BB, MBBI, Arg, Type::UIntTy, Op0Reg, Op1Reg);
-	       
-	       
   }
 
   std::vector<ValueRecord> Args;
diff --git a/lib/Transforms/Scalar/InstructionCombining.cpp b/lib/Transforms/Scalar/InstructionCombining.cpp
index 0ecec730d9..33de49d391 100644
--- a/lib/Transforms/Scalar/InstructionCombining.cpp
+++ b/lib/Transforms/Scalar/InstructionCombining.cpp
@@ -370,8 +370,7 @@ Instruction *InstCombiner::visitMul(BinaryOperator &I) {
   if (Constant *Op1 = dyn_cast<Constant>(I.getOperand(1))) {
     if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
       const Type *Ty = CI->getType();
-      int64_t Val = Ty->isSigned() ?        cast<ConstantSInt>(CI)->getValue() :
-                                   (int64_t)cast<ConstantUInt>(CI)->getValue();
+      int64_t Val = (int64_t)cast<ConstantInt>(CI)->getRawValue();
       switch (Val) {
       case -1:                               // X * -1 -> -X
         return BinaryOperator::createNeg(Op0, I.getName());
diff --git a/lib/Transforms/Scalar/ScalarReplAggregates.cpp b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
index f0e51e589d..fceaccc89a 100644
--- a/lib/Transforms/Scalar/ScalarReplAggregates.cpp
+++ b/lib/Transforms/Scalar/ScalarReplAggregates.cpp
@@ -103,11 +103,7 @@ bool SROA::runOnFunction(Function &F) {
       Instruction *User = cast<Instruction>(*I);
       if (GetElementPtrInst *GEPI = dyn_cast<GetElementPtrInst>(User)) {
         // We now know that the GEP is of the form: GEP <ptr>, 0, <cst>
-        uint64_t Idx;
-        if (ConstantSInt *CSI = dyn_cast<ConstantSInt>(GEPI->getOperand(2)))
-          Idx = CSI->getValue();
-        else
-          Idx = cast<ConstantUInt>(GEPI->getOperand(2))->getValue();
+        uint64_t Idx = cast<ConstantInt>(GEPI->getOperand(2))->getRawValue();
         
         assert(Idx < ElementAllocas.size() && "Index out of range?");
         AllocaInst *AllocaToUse = ElementAllocas[Idx];
diff --git a/lib/Transforms/TransformInternals.h b/lib/Transforms/TransformInternals.h
index 8cab429349..5f87a38cc4 100644
--- a/lib/Transforms/TransformInternals.h
+++ b/lib/Transforms/TransformInternals.h
@@ -16,9 +16,7 @@
 #include <set>
 
 static inline int64_t getConstantValue(const ConstantInt *CPI) {
-  if (const ConstantSInt *CSI = dyn_cast<ConstantSInt>(CPI))
-    return CSI->getValue();
-  return (int64_t)cast<ConstantUInt>(CPI)->getValue();
+  return (int64_t)cast<ConstantInt>(CPI)->getRawValue();
 }
 
 
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp
index 0c62d05d2b..545349a6f5 100644
--- a/lib/VMCore/AsmWriter.cpp
+++ b/lib/VMCore/AsmWriter.cpp
@@ -274,9 +274,7 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV,
     if (isString) {
       Out << "c\"";
       for (unsigned i = 0; i < CA->getNumOperands(); ++i) {
-        unsigned char C = (ETy == Type::SByteTy) ?
-          (unsigned char)cast<ConstantSInt>(CA->getOperand(i))->getValue() :
-          (unsigned char)cast<ConstantUInt>(CA->getOperand(i))->getValue();
+        unsigned char C = cast<ConstantInt>(CA->getOperand(i))->getRawValue();
         
         if (isprint(C) && C != '"' && C != '\\') {
           Out << C;
diff --git a/lib/VMCore/ConstantRange.cpp b/lib/VMCore/ConstantRange.cpp
index b7ef5e0511..c9d8ae6fbb 100644
--- a/lib/VMCore/ConstantRange.cpp
+++ b/lib/VMCore/ConstantRange.cpp
@@ -126,10 +126,7 @@ uint64_t ConstantRange::getSetSize() const {
   // Simply subtract the bounds...
   Constant *Result = *(Constant*)Upper - *(Constant*)Lower;
   assert(Result && "Subtraction of constant integers not implemented?");
-  if (getType()->isSigned())
-    return (uint64_t)cast<ConstantSInt>(Result)->getValue();
-  else
-    return cast<ConstantUInt>(Result)->getValue();
+  return cast<ConstantInt>(Result)->getRawValue();
 }
 
 
diff --git a/lib/VMCore/Constants.cpp b/lib/VMCore/Constants.cpp
index 935c2938c2..7bbbdb3202 100644
--- a/lib/VMCore/Constants.cpp
+++ b/lib/VMCore/Constants.cpp
@@ -601,15 +601,12 @@ ConstantArray *ConstantArray::get(const std::string &Str) {
 // Otherwise, it asserts out.
 //
 std::string ConstantArray::getAsString() const {
+  assert((getType()->getElementType() == Type::UByteTy ||
+          getType()->getElementType() == Type::SByteTy) && "Not a string!");
+
   std::string Result;
-  if (getType()->getElementType() == Type::SByteTy)
-    for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
-      Result += (char)cast<ConstantSInt>(getOperand(i))->getValue();
-  else {
-    assert(getType()->getElementType() == Type::UByteTy && "Not a string!");
-    for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
-      Result += (char)cast<ConstantUInt>(getOperand(i))->getValue();
-  }
+  for (unsigned i = 0, e = getNumOperands(); i != e; ++i)
+    Result += (char)cast<ConstantInt>(getOperand(i))->getRawValue();
   return Result;
 }