X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FConstantFold.cpp;h=1f75fe57d61884421da7d33a4116bb81b6d195d4;hb=83ad90a779f8ce46d6923bc6f63aa15b83968efb;hp=ed69814383d0dd468b576e9c8ef578a5d6bd2afb;hpb=4ada00d166b1d265fa4e751b63d7f869c7541f1b;p=oota-llvm.git diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index ed69814383d..1f75fe57d61 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -2,8 +2,8 @@ // // The LLVM Compiler Infrastructure // -// This file was developed by the LLVM research group and is distributed under -// the University of Illinois Open Source License. See LICENSE.TXT for details. +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // @@ -23,6 +23,7 @@ #include "llvm/Instructions.h" #include "llvm/DerivedTypes.h" #include "llvm/Function.h" +#include "llvm/GlobalAlias.h" #include "llvm/ADT/SmallVector.h" #include "llvm/Support/Compiler.h" #include "llvm/Support/GetElementPtrTypeIterator.h" @@ -35,86 +36,37 @@ using namespace llvm; // ConstantFold*Instruction Implementations //===----------------------------------------------------------------------===// -/// CastConstantVector - Convert the specified ConstantVector node to the +/// BitCastConstantVector - Convert the specified ConstantVector node to the /// specified vector type. At this point, we know that the elements of the -/// input packed constant are all simple integer or FP values. -static Constant *CastConstantVector(ConstantVector *CV, - const VectorType *DstTy) { - unsigned SrcNumElts = CV->getType()->getNumElements(); - unsigned DstNumElts = DstTy->getNumElements(); - const Type *SrcEltTy = CV->getType()->getElementType(); - const Type *DstEltTy = DstTy->getElementType(); +/// input vector constant are all simple integer or FP values. +static Constant *BitCastConstantVector(ConstantVector *CV, + const VectorType *DstTy) { + // If this cast changes element count then we can't handle it here: + // doing so requires endianness information. This should be handled by + // Analysis/ConstantFolding.cpp + unsigned NumElts = DstTy->getNumElements(); + if (NumElts != CV->getNumOperands()) + return 0; - // If both vectors have the same number of elements (thus, the elements - // are the same size), perform the conversion now. - if (SrcNumElts == DstNumElts) { - std::vector Result; - - // 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->isInteger() && DstEltTy->isInteger()) || - (SrcEltTy->isFloatingPoint() && DstEltTy->isFloatingPoint())) { - for (unsigned i = 0; i != SrcNumElts; ++i) - Result.push_back( - ConstantExpr::getBitCast(CV->getOperand(i), DstEltTy)); - return ConstantVector::get(Result); - } - - // If this is an int-to-fp cast .. - if (SrcEltTy->isInteger()) { - // Ensure that it is int-to-fp cast - assert(DstEltTy->isFloatingPoint()); - if (DstEltTy->getTypeID() == Type::DoubleTyID) { - for (unsigned i = 0; i != SrcNumElts; ++i) { - ConstantInt *CI = cast(CV->getOperand(i)); - double V = CI->getValue().bitsToDouble(); - Result.push_back(ConstantFP::get(Type::DoubleTy, V)); - } - return ConstantVector::get(Result); - } - assert(DstEltTy == Type::FloatTy && "Unknown fp type!"); - for (unsigned i = 0; i != SrcNumElts; ++i) { - ConstantInt *CI = cast(CV->getOperand(i)); - float V = CI->getValue().bitsToFloat(); - Result.push_back(ConstantFP::get(Type::FloatTy, V)); - } - return ConstantVector::get(Result); - } - - // Otherwise, this is an fp-to-int cast. - assert(SrcEltTy->isFloatingPoint() && DstEltTy->isInteger()); - - if (SrcEltTy->getTypeID() == Type::DoubleTyID) { - for (unsigned i = 0; i != SrcNumElts; ++i) { - uint64_t V = - DoubleToBits(cast(CV->getOperand(i))->getValue()); - Constant *C = ConstantInt::get(Type::Int64Ty, V); - Result.push_back(ConstantExpr::getBitCast(C, DstEltTy )); - } - return ConstantVector::get(Result); - } - - assert(SrcEltTy->getTypeID() == Type::FloatTyID); - for (unsigned i = 0; i != SrcNumElts; ++i) { - uint32_t V = FloatToBits(cast(CV->getOperand(i))->getValue()); - Constant *C = ConstantInt::get(Type::Int32Ty, V); - Result.push_back(ConstantExpr::getBitCast(C, DstEltTy)); - } - return ConstantVector::get(Result); + // Check to verify that all elements of the input are simple. + for (unsigned i = 0; i != NumElts; ++i) { + if (!isa(CV->getOperand(i)) && + !isa(CV->getOperand(i))) + return 0; } - - // Otherwise, this is a cast that changes element count and size. Handle - // casts which shrink the elements here. - - // FIXME: We need to know endianness to do this! - - return 0; + + // Bitcast each element now. + std::vector Result; + const Type *DstEltTy = DstTy->getElementType(); + for (unsigned i = 0; i != NumElts; ++i) + Result.push_back(ConstantExpr::getBitCast(CV->getOperand(i), DstEltTy)); + return ConstantVector::get(Result); } /// This function determines which opcode to use to fold two constant cast /// expressions together. It uses CastInst::isEliminableCastPair to determine /// the opcode. Consequently its just a wrapper around that function. -/// @Determine if it is valid to fold a cast of a cast +/// @brief Determine if it is valid to fold a cast of a cast static unsigned foldConstantCastPair( unsigned opc, ///< opcode of the second cast constant expression @@ -136,12 +88,102 @@ foldConstantCastPair( Type::Int64Ty); } -Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, - const Type *DestTy) { +static Constant *FoldBitCast(Constant *V, const Type *DestTy) { const Type *SrcTy = V->getType(); + if (SrcTy == DestTy) + return V; // no-op cast + + // Check to see if we are casting a pointer to an aggregate to a pointer to + // the first element. If so, return the appropriate GEP instruction. + if (const PointerType *PTy = dyn_cast(V->getType())) + if (const PointerType *DPTy = dyn_cast(DestTy)) + if (PTy->getAddressSpace() == DPTy->getAddressSpace()) { + SmallVector IdxList; + IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); + const Type *ElTy = PTy->getElementType(); + while (ElTy != DPTy->getElementType()) { + if (const StructType *STy = dyn_cast(ElTy)) { + if (STy->getNumElements() == 0) break; + ElTy = STy->getElementType(0); + IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); + } else if (const SequentialType *STy = + dyn_cast(ElTy)) { + if (isa(ElTy)) break; // Can't index into pointers! + ElTy = STy->getElementType(); + IdxList.push_back(IdxList[0]); + } else { + break; + } + } + + if (ElTy == DPTy->getElementType()) + return ConstantExpr::getGetElementPtr(V, &IdxList[0], IdxList.size()); + } + + // Handle casts from one vector constant to another. We know that the src + // and dest type have the same size (otherwise its an illegal cast). + if (const VectorType *DestPTy = dyn_cast(DestTy)) { + if (const VectorType *SrcTy = dyn_cast(V->getType())) { + assert(DestPTy->getBitWidth() == SrcTy->getBitWidth() && + "Not cast between same sized vectors!"); + // First, check for null. Undef is already handled. + if (isa(V)) + return Constant::getNullValue(DestTy); + + if (ConstantVector *CV = dyn_cast(V)) + return BitCastConstantVector(CV, DestPTy); + } + } + + // Finally, implement bitcast folding now. The code below doesn't handle + // bitcast right. + if (isa(V)) // ptr->ptr cast. + return ConstantPointerNull::get(cast(DestTy)); + + // Handle integral constant input. + if (const ConstantInt *CI = dyn_cast(V)) { + if (DestTy->isInteger()) + // Integral -> Integral. This is a no-op because the bit widths must + // be the same. Consequently, we just fold to V. + return V; + + if (DestTy->isFloatingPoint()) { + assert((DestTy == Type::DoubleTy || DestTy == Type::FloatTy) && + "Unknown FP type!"); + return ConstantFP::get(DestTy, APFloat(CI->getValue())); + } + // Otherwise, can't fold this (vector?) + return 0; + } + + // Handle ConstantFP input. + if (const ConstantFP *FP = dyn_cast(V)) { + // FP -> Integral. + if (DestTy == Type::Int32Ty) { + return ConstantInt::get(FP->getValueAPF().convertToAPInt()); + } else { + assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!"); + return ConstantInt::get(FP->getValueAPF().convertToAPInt()); + } + } + return 0; +} + - if (isa(V)) +Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, + const Type *DestTy) { + if (isa(V)) { + // zext(undef) = 0, because the top bits will be zero. + // sext(undef) = 0, because the top bits will all be the same. + // [us]itofp(undef) = 0, because the result value is bounded. + if (opc == Instruction::ZExt || opc == Instruction::SExt || + opc == Instruction::UIToFP || opc == Instruction::SIToFP) + return Constant::getNullValue(DestTy); return UndefValue::get(DestTy); + } + // No compile-time operations on this type yet. + if (V->getType() == Type::PPC_FP128Ty || DestTy == Type::PPC_FP128Ty) + return 0; // If the cast operand is a constant expression, there's a few things we can // do to try to simplify it. @@ -170,22 +212,37 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, switch (opc) { case Instruction::FPTrunc: case Instruction::FPExt: - if (const ConstantFP *FPC = dyn_cast(V)) - return ConstantFP::get(DestTy, FPC->getValue()); - return 0; // Can't fold. - case Instruction::FPToUI: if (const ConstantFP *FPC = dyn_cast(V)) { - uint32_t DestBitWidth = cast(DestTy)->getBitWidth(); - APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth)); - return ConstantInt::get(Val); + APFloat Val = FPC->getValueAPF(); + Val.convert(DestTy == Type::FloatTy ? APFloat::IEEEsingle : + DestTy == Type::DoubleTy ? APFloat::IEEEdouble : + DestTy == Type::X86_FP80Ty ? APFloat::x87DoubleExtended : + DestTy == Type::FP128Ty ? APFloat::IEEEquad : + APFloat::Bogus, + APFloat::rmNearestTiesToEven); + return ConstantFP::get(DestTy, Val); } return 0; // Can't fold. + case Instruction::FPToUI: case Instruction::FPToSI: if (const ConstantFP *FPC = dyn_cast(V)) { + const APFloat &V = FPC->getValueAPF(); + uint64_t x[2]; uint32_t DestBitWidth = cast(DestTy)->getBitWidth(); - APInt Val(APIntOps::RoundDoubleToAPInt(FPC->getValue(), DestBitWidth)); + (void) V.convertToInteger(x, DestBitWidth, opc==Instruction::FPToSI, + APFloat::rmTowardZero); + APInt Val(DestBitWidth, 2, x); return ConstantInt::get(Val); } + if (const ConstantVector *CV = dyn_cast(V)) { + std::vector res; + const VectorType *DestVecTy = cast(DestTy); + const Type *DstEltTy = DestVecTy->getElementType(); + for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) + res.push_back(ConstantFoldCastInstruction(opc, V->getOperand(i), + DstEltTy)); + return ConstantVector::get(DestVecTy, res); + } return 0; // Can't fold. case Instruction::IntToPtr: //always treated as unsigned if (V->isNullValue()) // Is it an integral null value? @@ -196,12 +253,26 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, return ConstantInt::get(DestTy, 0); return 0; // Other pointer types cannot be casted case Instruction::UIToFP: - if (const ConstantInt *CI = dyn_cast(V)) - return ConstantFP::get(DestTy, CI->getValue().roundToDouble()); - return 0; case Instruction::SIToFP: - if (const ConstantInt *CI = dyn_cast(V)) - return ConstantFP::get(DestTy, CI->getValue().signedRoundToDouble()); + if (const ConstantInt *CI = dyn_cast(V)) { + APInt api = CI->getValue(); + const uint64_t zero[] = {0, 0}; + APFloat apf = APFloat(APInt(DestTy->getPrimitiveSizeInBits(), + 2, zero)); + (void)apf.convertFromAPInt(api, + opc==Instruction::SIToFP, + APFloat::rmNearestTiesToEven); + return ConstantFP::get(DestTy, apf); + } + if (const ConstantVector *CV = dyn_cast(V)) { + std::vector res; + const VectorType *DestVecTy = cast(DestTy); + const Type *DstEltTy = DestVecTy->getElementType(); + for (unsigned i = 0, e = CV->getType()->getNumElements(); i != e; ++i) + res.push_back(ConstantFoldCastInstruction(opc, V->getOperand(i), + DstEltTy)); + return ConstantVector::get(DestVecTy, res); + } return 0; case Instruction::ZExt: if (const ConstantInt *CI = dyn_cast(V)) { @@ -228,103 +299,7 @@ Constant *llvm::ConstantFoldCastInstruction(unsigned opc, const Constant *V, } return 0; case Instruction::BitCast: - if (SrcTy == DestTy) - return (Constant*)V; // no-op cast - - // Check to see if we are casting a pointer to an aggregate to a pointer to - // the first element. If so, return the appropriate GEP instruction. - if (const PointerType *PTy = dyn_cast(V->getType())) - if (const PointerType *DPTy = dyn_cast(DestTy)) { - SmallVector IdxList; - IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); - const Type *ElTy = PTy->getElementType(); - while (ElTy != DPTy->getElementType()) { - if (const StructType *STy = dyn_cast(ElTy)) { - if (STy->getNumElements() == 0) break; - ElTy = STy->getElementType(0); - IdxList.push_back(Constant::getNullValue(Type::Int32Ty)); - } else if (const SequentialType *STy = - dyn_cast(ElTy)) { - if (isa(ElTy)) break; // Can't index into pointers! - ElTy = STy->getElementType(); - IdxList.push_back(IdxList[0]); - } else { - break; - } - } - - if (ElTy == DPTy->getElementType()) - return ConstantExpr::getGetElementPtr( - const_cast(V), &IdxList[0], IdxList.size()); - } - - // Handle casts from one packed constant to another. We know that the src - // and dest type have the same size (otherwise its an illegal cast). - if (const VectorType *DestPTy = dyn_cast(DestTy)) { - if (const VectorType *SrcTy = dyn_cast(V->getType())) { - assert(DestPTy->getBitWidth() == SrcTy->getBitWidth() && - "Not cast between same sized vectors!"); - // First, check for null and undef - if (isa(V)) - return Constant::getNullValue(DestTy); - if (isa(V)) - return UndefValue::get(DestTy); - - if (const ConstantVector *CV = dyn_cast(V)) { - // This is a cast from a ConstantVector of one type to a - // ConstantVector of another type. Check to see if all elements of - // the input are simple. - bool AllSimpleConstants = true; - for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) { - if (!isa(CV->getOperand(i)) && - !isa(CV->getOperand(i))) { - AllSimpleConstants = false; - break; - } - } - - // If all of the elements are simple constants, we can fold this. - if (AllSimpleConstants) - return CastConstantVector(const_cast(CV), DestPTy); - } - } - } - - // Finally, implement bitcast folding now. The code below doesn't handle - // bitcast right. - if (isa(V)) // ptr->ptr cast. - return ConstantPointerNull::get(cast(DestTy)); - - // Handle integral constant input. - if (const ConstantInt *CI = dyn_cast(V)) { - if (DestTy->isInteger()) - // Integral -> Integral. This is a no-op because the bit widths must - // be the same. Consequently, we just fold to V. - return const_cast(V); - - if (DestTy->isFloatingPoint()) { - if (DestTy == Type::FloatTy) - return ConstantFP::get(DestTy, CI->getValue().bitsToFloat()); - assert(DestTy == Type::DoubleTy && "Unknown FP type!"); - return ConstantFP::get(DestTy, CI->getValue().bitsToDouble()); - } - // Otherwise, can't fold this (packed?) - return 0; - } - - // Handle ConstantFP input. - if (const ConstantFP *FP = dyn_cast(V)) { - // FP -> Integral. - if (DestTy == Type::Int32Ty) { - APInt Val(32, 0); - return ConstantInt::get(Val.floatToBits(FP->getValue())); - } else { - assert(DestTy == Type::Int64Ty && "only support f32/f64 for now!"); - APInt Val(64, 0); - return ConstantInt::get(Val.doubleToBits(FP->getValue())); - } - } - return 0; + return FoldBitCast(const_cast(V), DestTy); default: assert(!"Invalid CE CastInst opcode"); break; @@ -373,7 +348,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, if (!CIdx) return 0; APInt idxVal = CIdx->getValue(); if (isa(Val)) { - // Insertion of scalar constant into packed undef + // Insertion of scalar constant into vector undef // Optimize away insertion of undef if (isa(Elt)) return const_cast(Val); @@ -391,7 +366,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, return ConstantVector::get(Ops); } if (isa(Val)) { - // Insertion of scalar constant into packed aggregate zero + // Insertion of scalar constant into vector aggregate zero // Optimize away insertion of zero if (Elt->isNullValue()) return const_cast(Val); @@ -409,7 +384,7 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, return ConstantVector::get(Ops); } if (const ConstantVector *CVal = dyn_cast(Val)) { - // Insertion of scalar constant into packed constant + // Insertion of scalar constant into vector constant std::vector Ops; Ops.reserve(CVal->getNumOperands()); for (unsigned i = 0; i < CVal->getNumOperands(); ++i) { @@ -422,35 +397,93 @@ Constant *llvm::ConstantFoldInsertElementInstruction(const Constant *Val, return 0; } +/// GetVectorElement - If C is a ConstantVector, ConstantAggregateZero or Undef +/// return the specified element value. Otherwise return null. +static Constant *GetVectorElement(const Constant *C, unsigned EltNo) { + if (const ConstantVector *CV = dyn_cast(C)) + return const_cast(CV->getOperand(EltNo)); + + const Type *EltTy = cast(C->getType())->getElementType(); + if (isa(C)) + return Constant::getNullValue(EltTy); + if (isa(C)) + return UndefValue::get(EltTy); + return 0; +} + Constant *llvm::ConstantFoldShuffleVectorInstruction(const Constant *V1, const Constant *V2, const Constant *Mask) { - // TODO: - return 0; + // Undefined shuffle mask -> undefined value. + if (isa(Mask)) return UndefValue::get(V1->getType()); + + unsigned NumElts = cast(V1->getType())->getNumElements(); + const Type *EltTy = cast(V1->getType())->getElementType(); + + // Loop over the shuffle mask, evaluating each element. + SmallVector Result; + for (unsigned i = 0; i != NumElts; ++i) { + Constant *InElt = GetVectorElement(Mask, i); + if (InElt == 0) return 0; + + if (isa(InElt)) + InElt = UndefValue::get(EltTy); + else if (ConstantInt *CI = dyn_cast(InElt)) { + unsigned Elt = CI->getZExtValue(); + if (Elt >= NumElts*2) + InElt = UndefValue::get(EltTy); + else if (Elt >= NumElts) + InElt = GetVectorElement(V2, Elt-NumElts); + else + InElt = GetVectorElement(V1, Elt); + if (InElt == 0) return 0; + } else { + // Unknown value. + return 0; + } + Result.push_back(InElt); + } + + return ConstantVector::get(&Result[0], Result.size()); } -/// EvalVectorOp - Given two packed constants and a function pointer, apply the +/// EvalVectorOp - Given two vector constants and a function pointer, apply the /// function pointer to each element pair, producing a new ConstantVector -/// constant. +/// constant. Either or both of V1 and V2 may be NULL, meaning a +/// ConstantAggregateZero operand. static Constant *EvalVectorOp(const ConstantVector *V1, const ConstantVector *V2, + const VectorType *VTy, Constant *(*FP)(Constant*, Constant*)) { std::vector Res; - for (unsigned i = 0, e = V1->getNumOperands(); i != e; ++i) - Res.push_back(FP(const_cast(V1->getOperand(i)), - const_cast(V2->getOperand(i)))); + const Type *EltTy = VTy->getElementType(); + for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { + const Constant *C1 = V1 ? V1->getOperand(i) : Constant::getNullValue(EltTy); + const Constant *C2 = V2 ? V2->getOperand(i) : Constant::getNullValue(EltTy); + Res.push_back(FP(const_cast(C1), + const_cast(C2))); + } return ConstantVector::get(Res); } Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, const Constant *C1, const Constant *C2) { + // No compile-time operations on this type yet. + if (C1->getType() == Type::PPC_FP128Ty) + return 0; + // Handle UndefValue up front if (isa(C1) || isa(C2)) { switch (Opcode) { + case Instruction::Xor: + if (isa(C1) && isa(C2)) + // Handle undef ^ undef -> 0 special case. This is a common + // idiom (misuse). + return Constant::getNullValue(C1->getType()); + // Fallthrough case Instruction::Add: case Instruction::Sub: - case Instruction::Xor: return UndefValue::get(C1->getType()); case Instruction::Mul: case Instruction::And: @@ -631,94 +664,94 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, case Instruction::Xor: return ConstantInt::get(C1V ^ C2V); case Instruction::Shl: - if (uint32_t shiftAmt = C2V.getZExtValue()) + if (uint32_t shiftAmt = C2V.getZExtValue()) { if (shiftAmt < C1V.getBitWidth()) return ConstantInt::get(C1V.shl(shiftAmt)); else return UndefValue::get(C1->getType()); // too big shift is undef + } return const_cast(CI1); // Zero shift is identity case Instruction::LShr: - if (uint32_t shiftAmt = C2V.getZExtValue()) + if (uint32_t shiftAmt = C2V.getZExtValue()) { if (shiftAmt < C1V.getBitWidth()) return ConstantInt::get(C1V.lshr(shiftAmt)); else return UndefValue::get(C1->getType()); // too big shift is undef + } return const_cast(CI1); // Zero shift is identity case Instruction::AShr: - if (uint32_t shiftAmt = C2V.getZExtValue()) + if (uint32_t shiftAmt = C2V.getZExtValue()) { if (shiftAmt < C1V.getBitWidth()) return ConstantInt::get(C1V.ashr(shiftAmt)); else return UndefValue::get(C1->getType()); // too big shift is undef + } return const_cast(CI1); // Zero shift is identity } } } else if (const ConstantFP *CFP1 = dyn_cast(C1)) { if (const ConstantFP *CFP2 = dyn_cast(C2)) { - double C1Val = CFP1->getValue(); - double C2Val = CFP2->getValue(); + APFloat C1V = CFP1->getValueAPF(); + APFloat C2V = CFP2->getValueAPF(); + APFloat C3V = C1V; // copy for modification + bool isDouble = CFP1->getType()==Type::DoubleTy; switch (Opcode) { default: break; - case Instruction::Add: - return ConstantFP::get(CFP1->getType(), C1Val + C2Val); + case Instruction::Add: + (void)C3V.add(C2V, APFloat::rmNearestTiesToEven); + return ConstantFP::get(CFP1->getType(), C3V); case Instruction::Sub: - return ConstantFP::get(CFP1->getType(), C1Val - C2Val); - case Instruction::Mul: - return ConstantFP::get(CFP1->getType(), C1Val * C2Val); + (void)C3V.subtract(C2V, APFloat::rmNearestTiesToEven); + return ConstantFP::get(CFP1->getType(), C3V); + case Instruction::Mul: + (void)C3V.multiply(C2V, APFloat::rmNearestTiesToEven); + return ConstantFP::get(CFP1->getType(), C3V); case Instruction::FDiv: - if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0)) - if (CFP1->isExactlyValue(0.0) || CFP1->isExactlyValue(-0.0)) - // IEEE 754, Section 7.1, #4 - return ConstantFP::get(CFP1->getType(), - std::numeric_limits::quiet_NaN()); - else if (CFP2->isExactlyValue(-0.0) || C1Val < 0.0) - // IEEE 754, Section 7.2, negative infinity case - return ConstantFP::get(CFP1->getType(), - -std::numeric_limits::infinity()); - else - // IEEE 754, Section 7.2, positive infinity case - return ConstantFP::get(CFP1->getType(), - std::numeric_limits::infinity()); - return ConstantFP::get(CFP1->getType(), C1Val / C2Val); + (void)C3V.divide(C2V, APFloat::rmNearestTiesToEven); + return ConstantFP::get(CFP1->getType(), C3V); case Instruction::FRem: - if (CFP2->isExactlyValue(0.0) || CFP2->isExactlyValue(-0.0)) + if (C2V.isZero()) // IEEE 754, Section 7.1, #5 - return ConstantFP::get(CFP1->getType(), - std::numeric_limits::quiet_NaN()); - return ConstantFP::get(CFP1->getType(), std::fmod(C1Val, C2Val)); - + return ConstantFP::get(CFP1->getType(), isDouble ? + APFloat(std::numeric_limits::quiet_NaN()) : + APFloat(std::numeric_limits::quiet_NaN())); + (void)C3V.mod(C2V, APFloat::rmNearestTiesToEven); + return ConstantFP::get(CFP1->getType(), C3V); } } - } else if (const ConstantVector *CP1 = dyn_cast(C1)) { - if (const ConstantVector *CP2 = dyn_cast(C2)) { + } else if (const VectorType *VTy = dyn_cast(C1->getType())) { + const ConstantVector *CP1 = dyn_cast(C1); + const ConstantVector *CP2 = dyn_cast(C2); + if ((CP1 != NULL || isa(C1)) && + (CP2 != NULL || isa(C2))) { switch (Opcode) { default: break; case Instruction::Add: - return EvalVectorOp(CP1, CP2, ConstantExpr::getAdd); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAdd); case Instruction::Sub: - return EvalVectorOp(CP1, CP2, ConstantExpr::getSub); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSub); case Instruction::Mul: - return EvalVectorOp(CP1, CP2, ConstantExpr::getMul); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getMul); case Instruction::UDiv: - return EvalVectorOp(CP1, CP2, ConstantExpr::getUDiv); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getUDiv); case Instruction::SDiv: - return EvalVectorOp(CP1, CP2, ConstantExpr::getSDiv); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSDiv); case Instruction::FDiv: - return EvalVectorOp(CP1, CP2, ConstantExpr::getFDiv); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFDiv); case Instruction::URem: - return EvalVectorOp(CP1, CP2, ConstantExpr::getURem); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getURem); case Instruction::SRem: - return EvalVectorOp(CP1, CP2, ConstantExpr::getSRem); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getSRem); case Instruction::FRem: - return EvalVectorOp(CP1, CP2, ConstantExpr::getFRem); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getFRem); case Instruction::And: - return EvalVectorOp(CP1, CP2, ConstantExpr::getAnd); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getAnd); case Instruction::Or: - return EvalVectorOp(CP1, CP2, ConstantExpr::getOr); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getOr); case Instruction::Xor: - return EvalVectorOp(CP1, CP2, ConstantExpr::getXor); + return EvalVectorOp(CP1, CP2, VTy, ConstantExpr::getXor); } } } @@ -798,6 +831,11 @@ static FCmpInst::Predicate evaluateFCmpRelation(const Constant *V1, const Constant *V2) { assert(V1->getType() == V2->getType() && "Cannot compare values of different types!"); + + // No compile-time operations on this type yet. + if (V1->getType() == Type::PPC_FP128Ty) + return FCmpInst::BAD_FCMP_PREDICATE; + // Handle degenerate case quickly if (V1 == V2) return FCmpInst::FCMP_OEQ; @@ -910,12 +948,14 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, // Now we know that the RHS is a GlobalValue or simple constant, // which (since the types must match) means that it's a ConstantPointerNull. if (const GlobalValue *CPR2 = dyn_cast(V2)) { - if (!CPR1->hasExternalWeakLinkage() || !CPR2->hasExternalWeakLinkage()) - return ICmpInst::ICMP_NE; + // Don't try to decide equality of aliases. + if (!isa(CPR1) && !isa(CPR2)) + if (!CPR1->hasExternalWeakLinkage() || !CPR2->hasExternalWeakLinkage()) + return ICmpInst::ICMP_NE; } else { - // GlobalVals can never be null. assert(isa(V2) && "Canonicalization guarantee!"); - if (!CPR1->hasExternalWeakLinkage()) + // GlobalVals can never be null. Don't try to evaluate aliases. + if (!CPR1->hasExternalWeakLinkage() && !isa(CPR1)) return ICmpInst::ICMP_NE; } } else { @@ -934,20 +974,19 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, case Instruction::UIToFP: case Instruction::SIToFP: - case Instruction::IntToPtr: case Instruction::BitCast: case Instruction::ZExt: case Instruction::SExt: - case Instruction::PtrToInt: // 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(CE1->getType()) || CE1->getType()->isInteger())) { - bool sgnd = CE1->getOpcode() == Instruction::ZExt ? false : - (CE1->getOpcode() == Instruction::SExt ? true : - (CE1->getOpcode() == Instruction::PtrToInt ? false : isSigned)); - return evaluateICmpRelation( - CE1Op0, Constant::getNullValue(CE1Op0->getType()), sgnd); + bool sgnd = isSigned; + if (CE1->getOpcode() == Instruction::ZExt) isSigned = false; + if (CE1->getOpcode() == Instruction::SExt) isSigned = true; + return evaluateICmpRelation(CE1Op0, + Constant::getNullValue(CE1Op0->getType()), + sgnd); } // If the dest type is a pointer type, and the RHS is a constantexpr cast @@ -958,11 +997,11 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, if (CE2->isCast() && isa(CE1->getType()) && CE1->getOperand(0)->getType() == CE2->getOperand(0)->getType() && CE1->getOperand(0)->getType()->isInteger()) { - bool sgnd = CE1->getOpcode() == Instruction::ZExt ? false : - (CE1->getOpcode() == Instruction::SExt ? true : - (CE1->getOpcode() == Instruction::PtrToInt ? false : isSigned)); + bool sgnd = isSigned; + if (CE1->getOpcode() == Instruction::ZExt) isSigned = false; + if (CE1->getOpcode() == Instruction::SExt) isSigned = true; return evaluateICmpRelation(CE1->getOperand(0), CE2->getOperand(0), - sgnd); + sgnd); } break; @@ -1051,18 +1090,20 @@ static ICmpInst::Predicate evaluateICmpRelation(const Constant *V1, // Ok, we ran out of things they have in common. If any leftovers // are non-zero then we have a difference, otherwise we are equal. for (; i < CE1->getNumOperands(); ++i) - if (!CE1->getOperand(i)->isNullValue()) + if (!CE1->getOperand(i)->isNullValue()) { if (isa(CE1->getOperand(i))) return isSigned ? ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT; else return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal. + } for (; i < CE2->getNumOperands(); ++i) - if (!CE2->getOperand(i)->isNullValue()) + if (!CE2->getOperand(i)->isNullValue()) { if (isa(CE2->getOperand(i))) return isSigned ? ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT; else return ICmpInst::BAD_ICMP_PREDICATE; // Might be equal. + } return ICmpInst::ICMP_EQ; } } @@ -1083,22 +1124,30 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, if (isa(C1) || isa(C2)) return UndefValue::get(Type::Int1Ty); + // No compile-time operations on this type yet. + if (C1->getType() == Type::PPC_FP128Ty) + return 0; + // icmp eq/ne(null,GV) -> false/true if (C1->isNullValue()) { if (const GlobalValue *GV = dyn_cast(C2)) - if (!GV->hasExternalWeakLinkage()) // External weak GV can be null + // Don't try to evaluate aliases. External weak GV can be null. + if (!isa(GV) && !GV->hasExternalWeakLinkage()) { if (pred == ICmpInst::ICMP_EQ) return ConstantInt::getFalse(); else if (pred == ICmpInst::ICMP_NE) return ConstantInt::getTrue(); + } // icmp eq/ne(GV,null) -> false/true } else if (C2->isNullValue()) { if (const GlobalValue *GV = dyn_cast(C1)) - if (!GV->hasExternalWeakLinkage()) // External weak GV can be null + // Don't try to evaluate aliases. External weak GV can be null. + if (!isa(GV) && !GV->hasExternalWeakLinkage()) { if (pred == ICmpInst::ICMP_EQ) return ConstantInt::getFalse(); else if (pred == ICmpInst::ICMP_NE) return ConstantInt::getTrue(); + } } if (isa(C1) && isa(C2)) { @@ -1118,52 +1167,47 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, case ICmpInst::ICMP_UGE:return ConstantInt::get(Type::Int1Ty, V1.uge(V2)); } } else if (isa(C1) && isa(C2)) { - double C1Val = cast(C1)->getValue(); - double C2Val = cast(C2)->getValue(); + APFloat C1V = cast(C1)->getValueAPF(); + APFloat C2V = cast(C2)->getValueAPF(); + APFloat::cmpResult R = C1V.compare(C2V); switch (pred) { default: assert(0 && "Invalid FCmp Predicate"); return 0; case FCmpInst::FCMP_FALSE: return ConstantInt::getFalse(); case FCmpInst::FCMP_TRUE: return ConstantInt::getTrue(); case FCmpInst::FCMP_UNO: - return ConstantInt::get(Type::Int1Ty, C1Val != C1Val || C2Val != C2Val); + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered); case FCmpInst::FCMP_ORD: - return ConstantInt::get(Type::Int1Ty, C1Val == C1Val && C2Val == C2Val); + return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpUnordered); case FCmpInst::FCMP_UEQ: - if (C1Val != C1Val || C2Val != C2Val) - return ConstantInt::getTrue(); - /* FALL THROUGH */ + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + R==APFloat::cmpEqual); case FCmpInst::FCMP_OEQ: - return ConstantInt::get(Type::Int1Ty, C1Val == C2Val); + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpEqual); case FCmpInst::FCMP_UNE: - if (C1Val != C1Val || C2Val != C2Val) - return ConstantInt::getTrue(); - /* FALL THROUGH */ + return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpEqual); case FCmpInst::FCMP_ONE: - return ConstantInt::get(Type::Int1Ty, C1Val != C2Val); + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan || + R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_ULT: - if (C1Val != C1Val || C2Val != C2Val) - return ConstantInt::getTrue(); - /* FALL THROUGH */ + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + R==APFloat::cmpLessThan); case FCmpInst::FCMP_OLT: - return ConstantInt::get(Type::Int1Ty, C1Val < C2Val); + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan); case FCmpInst::FCMP_UGT: - if (C1Val != C1Val || C2Val != C2Val) - return ConstantInt::getTrue(); - /* FALL THROUGH */ + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpUnordered || + R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_OGT: - return ConstantInt::get(Type::Int1Ty, C1Val > C2Val); + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan); case FCmpInst::FCMP_ULE: - if (C1Val != C1Val || C2Val != C2Val) - return ConstantInt::getTrue(); - /* FALL THROUGH */ + return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpGreaterThan); case FCmpInst::FCMP_OLE: - return ConstantInt::get(Type::Int1Ty, C1Val <= C2Val); + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpLessThan || + R==APFloat::cmpEqual); case FCmpInst::FCMP_UGE: - if (C1Val != C1Val || C2Val != C2Val) - return ConstantInt::getTrue(); - /* FALL THROUGH */ + return ConstantInt::get(Type::Int1Ty, R!=APFloat::cmpLessThan); case FCmpInst::FCMP_OGE: - return ConstantInt::get(Type::Int1Ty, C1Val >= C2Val); + return ConstantInt::get(Type::Int1Ty, R==APFloat::cmpGreaterThan || + R==APFloat::cmpEqual); } } else if (const ConstantVector *CP1 = dyn_cast(C1)) { if (const ConstantVector *CP2 = dyn_cast(C2)) { @@ -1345,18 +1389,20 @@ Constant *llvm::ConstantFoldCompareInstruction(unsigned short pred, } Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, - Constant* const *Idxs, + Constant* const *Idxs, unsigned NumIdx) { if (NumIdx == 0 || (NumIdx == 1 && Idxs[0]->isNullValue())) return const_cast(C); if (isa(C)) { - const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), - (Value**)Idxs, NumIdx, + const PointerType *Ptr = cast(C->getType()); + const Type *Ty = GetElementPtrInst::getIndexedType(Ptr, + (Value **)Idxs, + (Value **)Idxs+NumIdx, true); assert(Ty != 0 && "Invalid indices for GEP!"); - return UndefValue::get(PointerType::get(Ty)); + return UndefValue::get(PointerType::get(Ty, Ptr->getAddressSpace())); } Constant *Idx0 = Idxs[0]; @@ -1368,11 +1414,14 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, break; } if (isNull) { - const Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), - (Value**)Idxs, NumIdx, + const PointerType *Ptr = cast(C->getType()); + const Type *Ty = GetElementPtrInst::getIndexedType(Ptr, + (Value**)Idxs, + (Value**)Idxs+NumIdx, true); assert(Ty != 0 && "Invalid indices for GEP!"); - return ConstantPointerNull::get(PointerType::get(Ty)); + return + ConstantPointerNull::get(PointerType::get(Ty,Ptr->getAddressSpace())); } } @@ -1422,7 +1471,7 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, // long 0, long 0) // To: int* getelementptr ([3 x int]* %X, long 0, long 0) // - if (CE->isCast() && NumIdx > 1 && Idx0->isNullValue()) + if (CE->isCast() && NumIdx > 1 && Idx0->isNullValue()) { if (const PointerType *SPT = dyn_cast(CE->getOperand(0)->getType())) if (const ArrayType *SAT = dyn_cast(SPT->getElementType())) @@ -1431,6 +1480,28 @@ Constant *llvm::ConstantFoldGetElementPtr(const Constant *C, if (CAT->getElementType() == SAT->getElementType()) return ConstantExpr::getGetElementPtr( (Constant*)CE->getOperand(0), Idxs, NumIdx); + } + + // Fold: getelementptr (i8* inttoptr (i64 1 to i8*), i32 -1) + // Into: inttoptr (i64 0 to i8*) + // This happens with pointers to member functions in C++. + if (CE->getOpcode() == Instruction::IntToPtr && NumIdx == 1 && + isa(CE->getOperand(0)) && isa(Idxs[0]) && + cast(CE->getType())->getElementType() == Type::Int8Ty) { + Constant *Base = CE->getOperand(0); + Constant *Offset = Idxs[0]; + + // Convert the smaller integer to the larger type. + if (Offset->getType()->getPrimitiveSizeInBits() < + Base->getType()->getPrimitiveSizeInBits()) + Offset = ConstantExpr::getSExt(Offset, Base->getType()); + else if (Base->getType()->getPrimitiveSizeInBits() < + Offset->getType()->getPrimitiveSizeInBits()) + Base = ConstantExpr::getZExt(Base, Base->getType()); + + Base = ConstantExpr::getAdd(Base, Offset); + return ConstantExpr::getIntToPtr(Base, CE->getType()); + } } return 0; }