replica
/
hanchenye-llvm-project
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

whether the constant is signed or unsigned, then casting

llvm-svn: 7252
This commit is contained in:
Chris Lattner 2003-07-23 15:22:26 +00:00
parent 79f22fe02f
commit 6077c3195f
12 changed files with 30 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
llvm/lib/CWriter/Writer.cpp
View File

@ -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

5
llvm/lib/Support/ConstantRange.cpp
View File

@ -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();
}

4
llvm/lib/Target/Sparc/EmitAssembly.cpp
View File

@ -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 += "\\\"";

16
llvm/lib/Target/Sparc/SparcInstrInfo.cpp
View File

@ -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;
}

29
llvm/lib/Target/X86/InstSelectSimple.cpp
View File

@ -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;

21
llvm/lib/Target/X86/Printer.cpp
View File

@ -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
}

3
llvm/lib/Transforms/Scalar/InstructionCombining.cpp
View File

@ -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());

6
llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp
View File

@ -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];

4
llvm/lib/Transforms/TransformInternals.h
View File

@ -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();
}

4
llvm/lib/VMCore/AsmWriter.cpp
View File

@ -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;

13
llvm/lib/VMCore/Constants.cpp
View File

@ -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;
}

5
llvm/support/lib/Support/ConstantRange.cpp
View File

@ -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();
}