Changes in directory llvm/lib/Transforms/Scalar:
InstructionCombining.cpp updated: 1.520.2.1 -> 1.520.2.2 LoopStrengthReduce.cpp updated: 1.89.2.1 -> 1.89.2.2 LoopUnroll.cpp updated: 1.28 -> 1.28.2.1 Reassociate.cpp updated: 1.62 -> 1.62.2.1 ScalarReplAggregates.cpp updated: 1.44.2.1 -> 1.44.2.2 --- Log message: Make some simplifications for ConstantInt: 1. Get rid of getRawValue, replace with getZExtValue 2. Single constructor (uint64_t) and get method (int64_t) 3. Canonicalize the constant to a zero extended unsigned 64-bit integer when it is created. 4. Adjust getZExtValue() to be a do-nothing (just returns the already canonicalized value). 5. Compensate for above changes everywhere else. --- Diffs of the changes: (+50 -50) InstructionCombining.cpp | 78 +++++++++++++++++++++++------------------------ LoopStrengthReduce.cpp | 2 - LoopUnroll.cpp | 4 +- Reassociate.cpp | 2 - ScalarReplAggregates.cpp | 14 ++++---- 5 files changed, 50 insertions(+), 50 deletions(-) Index: llvm/lib/Transforms/Scalar/InstructionCombining.cpp diff -u llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.520.2.1 llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.520.2.2 --- llvm/lib/Transforms/Scalar/InstructionCombining.cpp:1.520.2.1 Wed Oct 18 22:57:56 2006 +++ llvm/lib/Transforms/Scalar/InstructionCombining.cpp Thu Oct 19 19:34:44 2006 @@ -1798,14 +1798,14 @@ if (Anded == CRHS) { // See if all bits from the first bit set in the Add RHS up are included // in the mask. First, get the rightmost bit. - uint64_t AddRHSV = CRHS->getRawValue(); + uint64_t AddRHSV = CRHS->getZExtValue(); // Form a mask of all bits from the lowest bit added through the top. uint64_t AddRHSHighBits = ~((AddRHSV & -AddRHSV)-1); AddRHSHighBits &= C2->getType()->getIntegralTypeMask(); // See if the and mask includes all of these bits. - uint64_t AddRHSHighBitsAnd = AddRHSHighBits & C2->getRawValue(); + uint64_t AddRHSHighBitsAnd = AddRHSHighBits & C2->getZExtValue(); if (AddRHSHighBits == AddRHSHighBitsAnd) { // Okay, the xform is safe. Insert the new add pronto. @@ -1848,7 +1848,7 @@ // highest order bit set. static bool isSignBit(ConstantInt *CI) { unsigned NumBits = CI->getType()->getPrimitiveSizeInBits(); - return (CI->getRawValue() & (~0ULL >> (64-NumBits))) == (1ULL << (NumBits-1)); + return (CI->getZExtValue() & (~0ULL >> (64-NumBits))) == (1ULL << (NumBits-1)); } /// RemoveNoopCast - Strip off nonconverting casts from the value. @@ -2064,7 +2064,7 @@ if (CI->isAllOnesValue()) // X * -1 == 0 - X return BinaryOperator::createNeg(Op0, I.getName()); - int64_t Val = (int64_t)cast<ConstantInt>(CI)->getRawValue(); + int64_t Val = (int64_t)cast<ConstantInt>(CI)->getZExtValue(); if (isPowerOf2_64(Val)) { // Replace X*(2^C) with X << C uint64_t C = Log2_64(Val); return new ShiftInst(Instruction::Shl, Op0, @@ -2290,7 +2290,7 @@ if (RHSI->getOpcode() == Instruction::Shl && isa<ConstantInt>(RHSI->getOperand(0)) && RHSI->getOperand(0)->getType()->isUnsigned()) { - uint64_t C1 = cast<ConstantInt>(RHSI->getOperand(0))->getRawValue(); + uint64_t C1 = cast<ConstantInt>(RHSI->getOperand(0))->getZExtValue(); if (isPowerOf2_64(C1)) { uint64_t C2 = Log2_64(C1); Value *Add = RHSI->getOperand(1); @@ -2515,17 +2515,17 @@ // isOneBitSet - Return true if there is exactly one bit set in the specified // constant. static bool isOneBitSet(const ConstantInt *CI) { - uint64_t V = CI->getRawValue(); + uint64_t V = CI->getZExtValue(); return V && (V & (V-1)) == 0; } #if 0 // Currently unused // isLowOnes - Return true if the constant is of the form 0+1+. static bool isLowOnes(const ConstantInt *CI) { - uint64_t V = CI->getRawValue(); + uint64_t V = CI->getZExtValue(); // There won't be bits set in parts that the type doesn't contain. - V &= ConstantInt::getAllOnesValue(CI->getType())->getRawValue(); + V &= ConstantInt::getAllOnesValue(CI->getType())->getZExtValue(); uint64_t U = V+1; // If it is low ones, this should be a power of two. return U && V && (U & V) == 0; @@ -2535,11 +2535,11 @@ // isHighOnes - Return true if the constant is of the form 1+0+. // This is the same as lowones(~X). static bool isHighOnes(const ConstantInt *CI) { - uint64_t V = ~CI->getRawValue(); + uint64_t V = ~CI->getZExtValue(); if (~V == 0) return false; // 0's does not match "1+" // There won't be bits set in parts that the type doesn't contain. - V &= ConstantInt::getAllOnesValue(CI->getType())->getRawValue(); + V &= ConstantInt::getAllOnesValue(CI->getType())->getZExtValue(); uint64_t U = V+1; // If it is low ones, this should be a power of two. return U && V && (U & V) == 0; @@ -2664,7 +2664,7 @@ // Adding a one to a single bit bit-field should be turned into an XOR // of the bit. First thing to check is to see if this AND is with a // single bit constant. - uint64_t AndRHSV = cast<ConstantInt>(AndRHS)->getRawValue(); + uint64_t AndRHSV = cast<ConstantInt>(AndRHS)->getZExtValue(); // Clear bits that are not part of the constant. AndRHSV &= AndRHS->getType()->getIntegralTypeMask(); @@ -2674,7 +2674,7 @@ // Ok, at this point, we know that we are masking the result of the // ADD down to exactly one bit. If the constant we are adding has // no bits set below this bit, then we can eliminate the ADD. - uint64_t AddRHS = cast<ConstantInt>(OpRHS)->getRawValue(); + uint64_t AddRHS = cast<ConstantInt>(OpRHS)->getZExtValue(); // Check to see if any bits below the one bit set in AndRHSV are set. if ((AddRHS & (AndRHSV-1)) == 0) { @@ -2810,7 +2810,7 @@ // MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is // not, since all 1s are not contiguous. static bool isRunOfOnes(ConstantIntegral *Val, unsigned &MB, unsigned &ME) { - uint64_t V = Val->getRawValue(); + uint64_t V = Val->getZExtValue(); if (!isShiftedMask_64(V)) return false; // look for the first zero bit after the run of ones @@ -2846,7 +2846,7 @@ case Instruction::And: if (ConstantExpr::getAnd(N, Mask) == Mask) { // If the AndRHS is a power of two minus one (0+1+), this is simple. - if ((Mask->getRawValue() & Mask->getRawValue()+1) == 0) + if ((Mask->getZExtValue() & Mask->getZExtValue()+1) == 0) break; // Otherwise, if Mask is 0+1+0+, and if B is known to have the low 0+ @@ -2864,7 +2864,7 @@ case Instruction::Or: case Instruction::Xor: // If the AndRHS is a power of two minus one (0+1+), and N&Mask == 0 - if ((Mask->getRawValue() & Mask->getRawValue()+1) == 0 && + if ((Mask->getZExtValue() & Mask->getZExtValue()+1) == 0 && ConstantExpr::getAnd(N, Mask)->isNullValue()) break; return 0; @@ -3178,7 +3178,7 @@ // defines a byte. We only handle unsigned types here. if (isa<ShiftInst>(I) && isa<ConstantInt>(I->getOperand(1))) { // Not shifting the entire input by N-1 bytes? - if (cast<ConstantInt>(I->getOperand(1))->getRawValue() != + if (cast<ConstantInt>(I->getOperand(1))->getZExtValue() != 8*(ByteValues.size()-1)) return true; @@ -3209,19 +3209,19 @@ Instruction *SI = cast<Instruction>(Shift); // Make sure that the shift amount is by a multiple of 8 and isn't too big. - if (ShiftAmt->getRawValue() & 7 || - ShiftAmt->getRawValue() > 8*ByteValues.size()) + if (ShiftAmt->getZExtValue() & 7 || + ShiftAmt->getZExtValue() > 8*ByteValues.size()) return true; // Turn 0xFF -> 0, 0xFF00 -> 1, 0xFF0000 -> 2, etc. unsigned DestByte; for (DestByte = 0; DestByte != ByteValues.size(); ++DestByte) - if (AndAmt->getRawValue() == uint64_t(0xFF) << 8*DestByte) + if (AndAmt->getZExtValue() == uint64_t(0xFF) << 8*DestByte) break; // Unknown mask for bswap. if (DestByte == ByteValues.size()) return true; - unsigned ShiftBytes = ShiftAmt->getRawValue()/8; + unsigned ShiftBytes = ShiftAmt->getZExtValue()/8; unsigned SrcByte; if (SI->getOpcode() == Instruction::Shl) SrcByte = DestByte - ShiftBytes; @@ -3382,7 +3382,7 @@ // replace with V+N. if (C1 == ConstantExpr::getNot(C2)) { Value *V1 = 0, *V2 = 0; - if ((C2->getRawValue() & (C2->getRawValue()+1)) == 0 && // C2 == 0+1+ + if ((C2->getZExtValue() & (C2->getZExtValue()+1)) == 0 && // C2 == 0+1+ match(A, m_Add(m_Value(V1), m_Value(V2)))) { // Add commutes, try both ways. if (V1 == B && MaskedValueIsZero(V2, C2->getZExtValue())) @@ -3391,7 +3391,7 @@ return ReplaceInstUsesWith(I, A); } // Or commutes, try both ways. - if ((C1->getRawValue() & (C1->getRawValue()+1)) == 0 && + if ((C1->getZExtValue() & (C1->getZExtValue()+1)) == 0 && match(B, m_Add(m_Value(V1), m_Value(V2)))) { // Add commutes, try both ways. if (V1 == A && MaskedValueIsZero(V2, C1->getZExtValue())) @@ -5082,7 +5082,7 @@ // operation. // if (isValid && !isLeftShift && isSignedShift) { - uint64_t Val = Op0C->getRawValue(); + uint64_t Val = Op0C->getZExtValue(); isValid = ((Val & (1 << (TypeBits-1))) != 0) == highBitSet; } @@ -5961,9 +5961,9 @@ if (ConstantInt *TrueValC = dyn_cast<ConstantInt>(TrueVal)) if (ConstantInt *FalseValC = dyn_cast<ConstantInt>(FalseVal)) { // select C, 1, 0 -> cast C to int - if (FalseValC->isNullValue() && TrueValC->getRawValue() == 1) { + if (FalseValC->isNullValue() && TrueValC->getZExtValue() == 1) { return new CastInst(CondVal, SI.getType()); - } else if (TrueValC->isNullValue() && FalseValC->getRawValue() == 1) { + } else if (TrueValC->isNullValue() && FalseValC->getZExtValue() == 1) { // select C, 0, 1 -> cast !C to int Value *NotCond = InsertNewInstBefore(BinaryOperator::createNot(CondVal, @@ -5983,7 +5983,7 @@ IC->getOpcode() == Instruction::SetLT; else { unsigned Bits = CmpCst->getType()->getPrimitiveSizeInBits(); - CanXForm = (CmpCst->getRawValue() == ~0ULL >> (64-Bits+1)) && + CanXForm = (CmpCst->getZExtValue() == ~0ULL >> (64-Bits+1)) && IC->getOpcode() == Instruction::SetGT; } @@ -6265,7 +6265,7 @@ if (NumBytes->isNullValue()) return EraseInstFromFunction(CI); if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) - if (CI->getRawValue() == 1) { + if (CI->getZExtValue() == 1) { // Replace the instruction with just byte operations. We would // transform other cases to loads/stores, but we don't know if // alignment is sufficient. @@ -6298,13 +6298,13 @@ unsigned Alignment1 = GetKnownAlignment(MI->getOperand(1), TD); unsigned Alignment2 = GetKnownAlignment(MI->getOperand(2), TD); unsigned Align = std::min(Alignment1, Alignment2); - if (MI->getAlignment()->getRawValue() < Align) { + if (MI->getAlignment()->getZExtValue() < Align) { MI->setAlignment(ConstantInt::get(Type::UIntTy, Align)); Changed = true; } } else if (isa<MemSetInst>(MI)) { unsigned Alignment = GetKnownAlignment(MI->getDest(), TD); - if (MI->getAlignment()->getRawValue() < Alignment) { + if (MI->getAlignment()->getZExtValue() < Alignment) { MI->setAlignment(ConstantInt::get(Type::UIntTy, Alignment)); Changed = true; } @@ -6388,7 +6388,7 @@ for (unsigned i = 0; i != 16; ++i) { if (isa<UndefValue>(Mask->getOperand(i))) continue; - unsigned Idx =cast<ConstantInt>(Mask->getOperand(i))->getRawValue(); + unsigned Idx =cast<ConstantInt>(Mask->getOperand(i))->getZExtValue(); Idx &= 31; // Match the hardware behavior. if (ExtractedElts[Idx] == 0) { @@ -7086,11 +7086,11 @@ // If the index will be to exactly the right offset with the scale taken // out, perform the transformation. - if (Scale && Scale->getRawValue() % ArrayEltSize == 0) { + if (Scale && Scale->getZExtValue() % ArrayEltSize == 0) { if (ConstantInt *C = dyn_cast<ConstantInt>(Scale)) Scale = ConstantInt::get(Scale->getType(), - Scale->getRawValue() / ArrayEltSize); - if (Scale->getRawValue() != 1) { + Scale->getZExtValue() / ArrayEltSize); + if (Scale->getZExtValue() != 1) { Constant *C = ConstantExpr::getCast(Scale, NewIdx->getType()); Instruction *Sc = BinaryOperator::createMul(NewIdx, C, "idxscale"); NewIdx = InsertNewInstBefore(Sc, GEP); @@ -7887,7 +7887,7 @@ if (!isa<ConstantInt>(IdxOp)) return false; - unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getRawValue(); + unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); if (isa<UndefValue>(ScalarOp)) { // inserting undef into vector. // Okay, we can handle this if the vector we are insertinting into is @@ -7901,7 +7901,7 @@ if (isa<ConstantInt>(EI->getOperand(1)) && EI->getOperand(0)->getType() == V->getType()) { unsigned ExtractedIdx = - cast<ConstantInt>(EI->getOperand(1))->getRawValue(); + cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); // This must be extracting from either LHS or RHS. if (EI->getOperand(0) == LHS || EI->getOperand(0) == RHS) { @@ -7955,8 +7955,8 @@ if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && EI->getOperand(0)->getType() == V->getType()) { unsigned ExtractedIdx = - cast<ConstantInt>(EI->getOperand(1))->getRawValue(); - unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getRawValue(); + cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); + unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); // Either the extracted from or inserted into vector must be RHSVec, // otherwise we'd end up with a shuffle of three inputs. @@ -8005,8 +8005,8 @@ if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp) && EI->getOperand(0)->getType() == IE.getType()) { unsigned NumVectorElts = IE.getType()->getNumElements(); - unsigned ExtractedIdx=cast<ConstantInt>(EI->getOperand(1))->getRawValue(); - unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getRawValue(); + unsigned ExtractedIdx=cast<ConstantInt>(EI->getOperand(1))->getZExtValue(); + unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue(); if (ExtractedIdx >= NumVectorElts) // Out of range extract. return ReplaceInstUsesWith(IE, VecOp); Index: llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp diff -u llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp:1.89.2.1 llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp:1.89.2.2 --- llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp:1.89.2.1 Wed Oct 18 22:57:56 2006 +++ llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp Thu Oct 19 19:34:44 2006 @@ -861,7 +861,7 @@ /// static bool isZero(SCEVHandle &V) { if (SCEVConstant *SC = dyn_cast<SCEVConstant>(V)) - return SC->getValue()->getRawValue() == 0; + return SC->getValue()->getZExtValue() == 0; return false; } Index: llvm/lib/Transforms/Scalar/LoopUnroll.cpp diff -u llvm/lib/Transforms/Scalar/LoopUnroll.cpp:1.28 llvm/lib/Transforms/Scalar/LoopUnroll.cpp:1.28.2.1 --- llvm/lib/Transforms/Scalar/LoopUnroll.cpp:1.28 Tue Aug 29 01:10:56 2006 +++ llvm/lib/Transforms/Scalar/LoopUnroll.cpp Thu Oct 19 19:34:44 2006 @@ -190,8 +190,8 @@ ConstantInt *TripCountC = dyn_cast_or_null<ConstantInt>(L->getTripCount()); if (!TripCountC) return Changed; // Must have constant trip count! - uint64_t TripCountFull = TripCountC->getRawValue(); - if (TripCountFull != TripCountC->getRawValue() || TripCountFull == 0) + uint64_t TripCountFull = TripCountC->getZExtValue(); + if (TripCountFull != TripCountC->getZExtValue() || TripCountFull == 0) return Changed; // More than 2^32 iterations??? unsigned LoopSize = ApproximateLoopSize(L); Index: llvm/lib/Transforms/Scalar/Reassociate.cpp diff -u llvm/lib/Transforms/Scalar/Reassociate.cpp:1.62 llvm/lib/Transforms/Scalar/Reassociate.cpp:1.62.2.1 --- llvm/lib/Transforms/Scalar/Reassociate.cpp:1.62 Sun Aug 27 17:42:52 2006 +++ llvm/lib/Transforms/Scalar/Reassociate.cpp Thu Oct 19 19:34:44 2006 @@ -549,7 +549,7 @@ if (CstVal->isNullValue()) { // ... * 0 -> 0 ++NumAnnihil; return CstVal; - } else if (cast<ConstantInt>(CstVal)->getRawValue() == 1) { + } else if (cast<ConstantInt>(CstVal)->getZExtValue() == 1) { Ops.pop_back(); // ... * 1 -> ... } break; Index: llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp diff -u llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp:1.44.2.1 llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp:1.44.2.2 --- llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp:1.44.2.1 Wed Oct 18 22:57:56 2006 +++ llvm/lib/Transforms/Scalar/ScalarReplAggregates.cpp Thu Oct 19 19:34:44 2006 @@ -203,7 +203,7 @@ GetElementPtrInst *GEPI = cast<GetElementPtrInst>(User); // We now know that the GEP is of the form: GEP <ptr>, 0, <cst> unsigned Idx = - (unsigned)cast<ConstantInt>(GEPI->getOperand(2))->getRawValue(); + (unsigned)cast<ConstantInt>(GEPI->getOperand(2))->getZExtValue(); assert(Idx < ElementAllocas.size() && "Index out of range?"); AllocaInst *AllocaToUse = ElementAllocas[Idx]; @@ -306,7 +306,7 @@ // Check to make sure that index falls within the array. If not, // something funny is going on, so we won't do the optimization. // - if (cast<ConstantInt>(GEPI->getOperand(2))->getRawValue() >= NumElements) + if (cast<ConstantInt>(GEPI->getOperand(2))->getZExtValue() >= NumElements) return 0; // We cannot scalar repl this level of the array unless any array @@ -320,7 +320,7 @@ const ArrayType *SubArrayTy = cast<ArrayType>(*I); uint64_t NumElements = SubArrayTy->getNumElements(); if (!isa<ConstantInt>(I.getOperand())) return 0; - if (cast<ConstantInt>(I.getOperand())->getRawValue() >= NumElements) + if (cast<ConstantInt>(I.getOperand())->getZExtValue() >= NumElements) return 0; } @@ -499,7 +499,7 @@ } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(User)) { // Check to see if this is stepping over an element: GEP Ptr, int C if (GEP->getNumOperands() == 2 && isa<ConstantInt>(GEP->getOperand(1))) { - unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getZExtValue(); unsigned ElSize = TD.getTypeSize(PTy->getElementType()); unsigned BitOffset = Idx*ElSize*8; if (BitOffset > 64 || !isPowerOf2_32(ElSize)) return 0; @@ -520,7 +520,7 @@ // We are stepping into an element, e.g. a structure or an array: // GEP Ptr, int 0, uint C const Type *AggTy = PTy->getElementType(); - unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue(); if (const ArrayType *ATy = dyn_cast<ArrayType>(AggTy)) { if (Idx >= ATy->getNumElements()) return 0; // Out of range. @@ -688,7 +688,7 @@ // Check to see if this is stepping over an element: GEP Ptr, int C unsigned NewOffset = Offset; if (GEP->getNumOperands() == 2) { - unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(1))->getZExtValue(); unsigned BitOffset = Idx*AggSizeInBits; if (TD.isLittleEndian() || isVectorInsert) @@ -698,7 +698,7 @@ } else if (GEP->getNumOperands() == 3) { // We know that operand #2 is zero. - unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getRawValue(); + unsigned Idx = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue(); const Type *AggTy = AggPtrTy->getElementType(); if (const SequentialType *SeqTy = dyn_cast<SequentialType>(AggTy)) { unsigned ElSizeBits = TD.getTypeSize(SeqTy->getElementType())*8; _______________________________________________ llvm-commits mailing list llvm-commits@cs.uiuc.edu http://lists.cs.uiuc.edu/mailman/listinfo/llvm-commits