From 943ce55f395ded8654a9a84ac8fc0fc9ee61483a Mon Sep 17 00:00:00 2001 From: Juergen Ributzka Date: Sat, 25 Jan 2014 02:02:55 +0000 Subject: [PATCH] Revert "Revert "Add Constant Hoisting Pass" (r200034)" This reverts commit r200058 and adds the using directive for ARMTargetTransformInfo to silence two g++ overload warnings. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@200062 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Analysis/TargetTransformInfo.h | 8 + include/llvm/CodeGen/SelectionDAG.h | 22 +- include/llvm/CodeGen/SelectionDAGNodes.h | 5 +- include/llvm/InitializePasses.h | 1 + include/llvm/LinkAllPasses.h | 1 + include/llvm/Transforms/Scalar.h | 6 + lib/Analysis/TargetTransformInfo.cpp | 22 +- lib/CodeGen/Passes.cpp | 6 + lib/CodeGen/SelectionDAG/DAGCombiner.cpp | 9 +- lib/CodeGen/SelectionDAG/SelectionDAG.cpp | 41 +- .../SelectionDAG/SelectionDAGBuilder.cpp | 3 + .../SelectionDAG/SelectionDAGDumper.cpp | 10 +- lib/CodeGen/SelectionDAG/TargetLowering.cpp | 18 +- lib/Target/ARM/ARMTargetTransformInfo.cpp | 2 +- lib/Target/X86/X86TargetTransformInfo.cpp | 95 ++++ lib/Transforms/Scalar/CMakeLists.txt | 1 + lib/Transforms/Scalar/CodeGenPrepare.cpp | 4 +- lib/Transforms/Scalar/ConstantHoisting.cpp | 436 ++++++++++++++++++ lib/Transforms/Scalar/Scalar.cpp | 1 + test/CodeGen/ARM/memcpy-inline.ll | 6 +- test/CodeGen/X86/large-constants.ll | 67 +++ 21 files changed, 723 insertions(+), 41 deletions(-) create mode 100644 lib/Transforms/Scalar/ConstantHoisting.cpp create mode 100644 test/CodeGen/X86/large-constants.ll diff --git a/include/llvm/Analysis/TargetTransformInfo.h b/include/llvm/Analysis/TargetTransformInfo.h index a8975b7a4f9..f2613e35c5e 100644 --- a/include/llvm/Analysis/TargetTransformInfo.h +++ b/include/llvm/Analysis/TargetTransformInfo.h @@ -92,6 +92,7 @@ public: enum TargetCostConstants { TCC_Free = 0, ///< Expected to fold away in lowering. TCC_Basic = 1, ///< The cost of a typical 'add' instruction. + TCC_Load = 3, TCC_Expensive = 4 ///< The cost of a 'div' instruction on x86. }; @@ -299,6 +300,13 @@ public: /// immediate of the specified type. virtual unsigned getIntImmCost(const APInt &Imm, Type *Ty) const; + /// \brief Return the expected cost of materialization for the given integer + /// immediate of the specified type for a given instruction. The cost can be + /// zero if the immediate can be folded into the specified instruction. + virtual unsigned getIntImmCost(unsigned Opcode, const APInt &Imm, + Type *Ty) const; + virtual unsigned getIntImmCost(Intrinsic::ID IID, const APInt &Imm, + Type *Ty) const; /// @} /// \name Vector Target Information diff --git a/include/llvm/CodeGen/SelectionDAG.h b/include/llvm/CodeGen/SelectionDAG.h index 82becca315a..523c81337cc 100644 --- a/include/llvm/CodeGen/SelectionDAG.h +++ b/include/llvm/CodeGen/SelectionDAG.h @@ -401,18 +401,22 @@ public: //===--------------------------------------------------------------------===// // Node creation methods. // - SDValue getConstant(uint64_t Val, EVT VT, bool isTarget = false); - SDValue getConstant(const APInt &Val, EVT VT, bool isTarget = false); - SDValue getConstant(const ConstantInt &Val, EVT VT, bool isTarget = false); + SDValue getConstant(uint64_t Val, EVT VT, bool isTarget = false, + bool isOpaque = false); + SDValue getConstant(const APInt &Val, EVT VT, bool isTarget = false, + bool isOpaque = false); + SDValue getConstant(const ConstantInt &Val, EVT VT, bool isTarget = false, + bool isOpaque = false); SDValue getIntPtrConstant(uint64_t Val, bool isTarget = false); - SDValue getTargetConstant(uint64_t Val, EVT VT) { - return getConstant(Val, VT, true); + SDValue getTargetConstant(uint64_t Val, EVT VT, bool isOpaque = false) { + return getConstant(Val, VT, true, isOpaque); } - SDValue getTargetConstant(const APInt &Val, EVT VT) { - return getConstant(Val, VT, true); + SDValue getTargetConstant(const APInt &Val, EVT VT, bool isOpaque = false) { + return getConstant(Val, VT, true, isOpaque); } - SDValue getTargetConstant(const ConstantInt &Val, EVT VT) { - return getConstant(Val, VT, true); + SDValue getTargetConstant(const ConstantInt &Val, EVT VT, + bool isOpaque = false) { + return getConstant(Val, VT, true, isOpaque); } // The forms below that take a double should only be used for simple // constants that can be exactly represented in VT. No checks are made. diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h index 00773b3e661..976d212ce3d 100644 --- a/include/llvm/CodeGen/SelectionDAGNodes.h +++ b/include/llvm/CodeGen/SelectionDAGNodes.h @@ -1250,9 +1250,10 @@ public: class ConstantSDNode : public SDNode { const ConstantInt *Value; friend class SelectionDAG; - ConstantSDNode(bool isTarget, const ConstantInt *val, EVT VT) + ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT) : SDNode(isTarget ? ISD::TargetConstant : ISD::Constant, 0, DebugLoc(), getSDVTList(VT)), Value(val) { + SubclassData |= isOpaque; } public: @@ -1265,6 +1266,8 @@ public: bool isNullValue() const { return Value->isNullValue(); } bool isAllOnesValue() const { return Value->isAllOnesValue(); } + bool isOpaque() const { return SubclassData & 1; } + static bool classof(const SDNode *N) { return N->getOpcode() == ISD::Constant || N->getOpcode() == ISD::TargetConstant; diff --git a/include/llvm/InitializePasses.h b/include/llvm/InitializePasses.h index 36efee570b4..923571ea4b9 100644 --- a/include/llvm/InitializePasses.h +++ b/include/llvm/InitializePasses.h @@ -90,6 +90,7 @@ void initializeCFGSimplifyPassPass(PassRegistry&); void initializeFlattenCFGPassPass(PassRegistry&); void initializeStructurizeCFGPass(PassRegistry&); void initializeCFGViewerPass(PassRegistry&); +void initializeConstantHoistingPass(PassRegistry&); void initializeCodeGenPreparePass(PassRegistry&); void initializeConstantMergePass(PassRegistry&); void initializeConstantPropagationPass(PassRegistry&); diff --git a/include/llvm/LinkAllPasses.h b/include/llvm/LinkAllPasses.h index e1d788e6e0a..16032504cb9 100644 --- a/include/llvm/LinkAllPasses.h +++ b/include/llvm/LinkAllPasses.h @@ -129,6 +129,7 @@ namespace { (void) llvm::createJumpThreadingPass(); (void) llvm::createUnifyFunctionExitNodesPass(); (void) llvm::createInstCountPass(); + (void) llvm::createConstantHoistingPass(); (void) llvm::createCodeGenPreparePass(); (void) llvm::createEarlyCSEPass(); (void) llvm::createGVNPass(); diff --git a/include/llvm/Transforms/Scalar.h b/include/llvm/Transforms/Scalar.h index 6f9e1245e51..e1890f68038 100644 --- a/include/llvm/Transforms/Scalar.h +++ b/include/llvm/Transforms/Scalar.h @@ -310,6 +310,12 @@ FunctionPass *createMemCpyOptPass(); // Pass *createLoopDeletionPass(); +//===----------------------------------------------------------------------===// +// +// ConstantHoisting - This pass prepares a function for expensive constants. +// +FunctionPass *createConstantHoistingPass(); + //===----------------------------------------------------------------------===// // // CodeGenPrepare - This pass prepares a function for instruction selection. diff --git a/lib/Analysis/TargetTransformInfo.cpp b/lib/Analysis/TargetTransformInfo.cpp index 360c4f5f1b1..decb9aec4d9 100644 --- a/lib/Analysis/TargetTransformInfo.cpp +++ b/lib/Analysis/TargetTransformInfo.cpp @@ -158,6 +158,16 @@ unsigned TargetTransformInfo::getIntImmCost(const APInt &Imm, Type *Ty) const { return PrevTTI->getIntImmCost(Imm, Ty); } +unsigned TargetTransformInfo::getIntImmCost(unsigned Opcode, const APInt &Imm, + Type *Ty) const { + return PrevTTI->getIntImmCost(Opcode, Imm, Ty); +} + +unsigned TargetTransformInfo::getIntImmCost(Intrinsic::ID IID, const APInt &Imm, + Type *Ty) const { + return PrevTTI->getIntImmCost(IID, Imm, Ty); +} + unsigned TargetTransformInfo::getNumberOfRegisters(bool Vector) const { return PrevTTI->getNumberOfRegisters(Vector); } @@ -541,7 +551,17 @@ struct NoTTI LLVM_FINAL : ImmutablePass, TargetTransformInfo { } unsigned getIntImmCost(const APInt &Imm, Type *Ty) const LLVM_OVERRIDE { - return 1; + return TCC_Basic; + } + + unsigned getIntImmCost(unsigned Opcode, const APInt &Imm, + Type *Ty) const LLVM_OVERRIDE { + return TCC_Free; + } + + unsigned getIntImmCost(Intrinsic::ID IID, const APInt &Imm, + Type *Ty) const LLVM_OVERRIDE { + return TCC_Free; } unsigned getNumberOfRegisters(bool Vector) const LLVM_OVERRIDE { diff --git a/lib/CodeGen/Passes.cpp b/lib/CodeGen/Passes.cpp index 0e8e50eca79..7a7c42bfcc6 100644 --- a/lib/CodeGen/Passes.cpp +++ b/lib/CodeGen/Passes.cpp @@ -70,6 +70,8 @@ static cl::opt DisableMachineSink("disable-machine-sink", cl::Hidden, cl::desc("Disable Machine Sinking")); static cl::opt DisableLSR("disable-lsr", cl::Hidden, cl::desc("Disable Loop Strength Reduction Pass")); +static cl::opt DisableConstantHoisting("disable-constant-hoisting", + cl::Hidden, cl::desc("Disable ConstantHoisting")); static cl::opt DisableCGP("disable-cgp", cl::Hidden, cl::desc("Disable Codegen Prepare")); static cl::opt DisableCopyProp("disable-copyprop", cl::Hidden, @@ -396,6 +398,10 @@ void TargetPassConfig::addIRPasses() { // Make sure that no unreachable blocks are instruction selected. addPass(createUnreachableBlockEliminationPass()); + + // Prepare expensive constants for SelectionDAG. + if (getOptLevel() != CodeGenOpt::None && !DisableConstantHoisting) + addPass(createConstantHoistingPass()); } /// Turn exception handling constructs into something the code generators can diff --git a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp index 69e2ce198e0..3fa2a32e868 100644 --- a/lib/CodeGen/SelectionDAG/DAGCombiner.cpp +++ b/lib/CodeGen/SelectionDAG/DAGCombiner.cpp @@ -3212,11 +3212,14 @@ SDValue DAGCombiner::visitOR(SDNode *N) { if (N1C && N0.getOpcode() == ISD::AND && N0.getNode()->hasOneUse() && isa(N0.getOperand(1))) { ConstantSDNode *C1 = cast(N0.getOperand(1)); - if ((C1->getAPIntValue() & N1C->getAPIntValue()) != 0) + if ((C1->getAPIntValue() & N1C->getAPIntValue()) != 0) { + SDValue COR = DAG.FoldConstantArithmetic(ISD::OR, VT, N1C, C1); + if (!COR.getNode()) + return SDValue(); return DAG.getNode(ISD::AND, SDLoc(N), VT, DAG.getNode(ISD::OR, SDLoc(N0), VT, - N0.getOperand(0), N1), - DAG.FoldConstantArithmetic(ISD::OR, VT, N1C, C1)); + N0.getOperand(0), N1), COR); + } } // fold (or (setcc x), (setcc y)) -> (setcc (or x, y)) if (isSetCCEquivalent(N0, LL, LR, CC0) && isSetCCEquivalent(N1, RL, RR, CC1)){ diff --git a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index e003caeddb1..430736aa46f 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -384,9 +384,12 @@ static void AddNodeIDCustom(FoldingSetNodeID &ID, const SDNode *N) { llvm_unreachable("Should only be used on nodes with operands"); default: break; // Normal nodes don't need extra info. case ISD::TargetConstant: - case ISD::Constant: - ID.AddPointer(cast(N)->getConstantIntValue()); + case ISD::Constant: { + const ConstantSDNode *C = cast(N); + ID.AddPointer(C->getConstantIntValue()); + ID.AddBoolean(C->isOpaque()); break; + } case ISD::TargetConstantFP: case ISD::ConstantFP: { ID.AddPointer(cast(N)->getConstantFPValue()); @@ -971,19 +974,21 @@ SDValue SelectionDAG::getNOT(SDLoc DL, SDValue Val, EVT VT) { return getNode(ISD::XOR, DL, VT, Val, NegOne); } -SDValue SelectionDAG::getConstant(uint64_t Val, EVT VT, bool isT) { +SDValue SelectionDAG::getConstant(uint64_t Val, EVT VT, bool isT, bool isO) { EVT EltVT = VT.getScalarType(); assert((EltVT.getSizeInBits() >= 64 || (uint64_t)((int64_t)Val >> EltVT.getSizeInBits()) + 1 < 2) && "getConstant with a uint64_t value that doesn't fit in the type!"); - return getConstant(APInt(EltVT.getSizeInBits(), Val), VT, isT); + return getConstant(APInt(EltVT.getSizeInBits(), Val), VT, isT, isO); } -SDValue SelectionDAG::getConstant(const APInt &Val, EVT VT, bool isT) { - return getConstant(*ConstantInt::get(*Context, Val), VT, isT); +SDValue SelectionDAG::getConstant(const APInt &Val, EVT VT, bool isT, bool isO) +{ + return getConstant(*ConstantInt::get(*Context, Val), VT, isT, isO); } -SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT) { +SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT, + bool isO) { assert(VT.isInteger() && "Cannot create FP integer constant!"); EVT EltVT = VT.getScalarType(); @@ -1025,7 +1030,7 @@ SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT) { for (unsigned i = 0; i < ViaVecNumElts / VT.getVectorNumElements(); ++i) { EltParts.push_back(getConstant(NewVal.lshr(i * ViaEltSizeInBits) .trunc(ViaEltSizeInBits), - ViaEltVT, isT)); + ViaEltVT, isT, isO)); } // EltParts is currently in little endian order. If we actually want @@ -1056,6 +1061,7 @@ SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT) { FoldingSetNodeID ID; AddNodeIDNode(ID, Opc, getVTList(EltVT), 0, 0); ID.AddPointer(Elt); + ID.AddBoolean(isO); void *IP = 0; SDNode *N = NULL; if ((N = CSEMap.FindNodeOrInsertPos(ID, IP))) @@ -1063,7 +1069,7 @@ SDValue SelectionDAG::getConstant(const ConstantInt &Val, EVT VT, bool isT) { return SDValue(N, 0); if (!N) { - N = new (NodeAllocator) ConstantSDNode(isT, Elt, EltVT); + N = new (NodeAllocator) ConstantSDNode(isT, isO, Elt, EltVT); CSEMap.InsertNode(N, IP); AllNodes.push_back(N); } @@ -2789,10 +2795,13 @@ SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, EVT VT, ConstantSDNode *Scalar1 = dyn_cast(Cst1); ConstantSDNode *Scalar2 = dyn_cast(Cst2); - if (Scalar1 && Scalar2) { + if (Scalar1 && Scalar2 && (Scalar1->isOpaque() || Scalar2->isOpaque())) + return SDValue(); + + if (Scalar1 && Scalar2) // Scalar instruction. Inputs.push_back(std::make_pair(Scalar1, Scalar2)); - } else { + else { // For vectors extract each constant element into Inputs so we can constant // fold them individually. BuildVectorSDNode *BV1 = dyn_cast(Cst1); @@ -2808,6 +2817,9 @@ SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, EVT VT, if (!V1 || !V2) // Not a constant, bail. return SDValue(); + if (V1->isOpaque() || V2->isOpaque()) + return SDValue(); + // Avoid BUILD_VECTOR nodes that perform implicit truncation. // FIXME: This is valid and could be handled by truncating the APInts. if (V1->getValueType(0) != SVT || V2->getValueType(0) != SVT) @@ -3561,10 +3573,11 @@ static SDValue getMemsetStringVal(EVT VT, SDLoc dl, SelectionDAG &DAG, Val |= (uint64_t)(unsigned char)Str[i] << (NumVTBytes-i-1)*8; } - // If the "cost" of materializing the integer immediate is 1 or free, then - // it is cost effective to turn the load into the immediate. + // If the "cost" of materializing the integer immediate is less than the cost + // of a load, then it is cost effective to turn the load into the immediate. const TargetTransformInfo *TTI = DAG.getTargetTransformInfo(); - if (TTI->getIntImmCost(Val, VT.getTypeForEVT(*DAG.getContext())) < 2) + if (TTI->getIntImmCost(Val, VT.getTypeForEVT(*DAG.getContext())) < + TargetTransformInfo::TCC_Load) return DAG.getConstant(Val, VT); return SDValue(0, 0); } diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 6c8e2f83a4f..a561c5190ac 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -2945,6 +2945,9 @@ void SelectionDAGBuilder::visitBitCast(const User &I) { if (DestVT != N.getValueType()) setValue(&I, DAG.getNode(ISD::BITCAST, getCurSDLoc(), DestVT, N)); // convert types. + else if(ConstantSDNode *C = dyn_cast(N)) + setValue(&I, DAG.getConstant(C->getAPIntValue(), C->getValueType(0), + /*isTarget=*/false, /*isOpaque*/true)); else setValue(&I, N); // noop cast. } diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp index 79377f74247..6f980884bea 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGDumper.cpp @@ -81,7 +81,10 @@ std::string SDNode::getOperationName(const SelectionDAG *G) const { case ISD::VALUETYPE: return "ValueType"; case ISD::Register: return "Register"; case ISD::RegisterMask: return "RegisterMask"; - case ISD::Constant: return "Constant"; + case ISD::Constant: + if (cast(this)->isOpaque()) + return "OpaqueConstant"; + return "Constant"; case ISD::ConstantFP: return "ConstantFP"; case ISD::GlobalAddress: return "GlobalAddress"; case ISD::GlobalTLSAddress: return "GlobalTLSAddress"; @@ -111,7 +114,10 @@ std::string SDNode::getOperationName(const SelectionDAG *G) const { } case ISD::BUILD_VECTOR: return "BUILD_VECTOR"; - case ISD::TargetConstant: return "TargetConstant"; + case ISD::TargetConstant: + if (cast(this)->isOpaque()) + return "OpaqueTargetConstant"; + return "TargetConstant"; case ISD::TargetConstantFP: return "TargetConstantFP"; case ISD::TargetGlobalAddress: return "TargetGlobalAddress"; case ISD::TargetGlobalTLSAddress: return "TargetGlobalTLSAddress"; diff --git a/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/lib/CodeGen/SelectionDAG/TargetLowering.cpp index fa5f9b4c942..6052a486408 100644 --- a/lib/CodeGen/SelectionDAG/TargetLowering.cpp +++ b/lib/CodeGen/SelectionDAG/TargetLowering.cpp @@ -1470,17 +1470,23 @@ TargetLowering::SimplifySetCC(EVT VT, SDValue N0, SDValue N1, if (Cond == ISD::SETGE || Cond == ISD::SETUGE) { if (C1 == MinVal) return DAG.getConstant(1, VT); // X >= MIN --> true // X >= C0 --> X > (C0-1) - return DAG.getSetCC(dl, VT, N0, - DAG.getConstant(C1-1, N1.getValueType()), - (Cond == ISD::SETGE) ? ISD::SETGT : ISD::SETUGT); + APInt C = C1-1; + if (!N1C->isOpaque() || (N1C->isOpaque() && C.getBitWidth() <= 64 && + isLegalICmpImmediate(C.getSExtValue()))) + return DAG.getSetCC(dl, VT, N0, + DAG.getConstant(C, N1.getValueType()), + (Cond == ISD::SETGE) ? ISD::SETGT : ISD::SETUGT); } if (Cond == ISD::SETLE || Cond == ISD::SETULE) { if (C1 == MaxVal) return DAG.getConstant(1, VT); // X <= MAX --> true // X <= C0 --> X < (C0+1) - return DAG.getSetCC(dl, VT, N0, - DAG.getConstant(C1+1, N1.getValueType()), - (Cond == ISD::SETLE) ? ISD::SETLT : ISD::SETULT); + APInt C = C1+1; + if (!N1C->isOpaque() || (N1C->isOpaque() && C.getBitWidth() <= 64 && + isLegalICmpImmediate(C.getSExtValue()))) + return DAG.getSetCC(dl, VT, N0, + DAG.getConstant(C, N1.getValueType()), + (Cond == ISD::SETLE) ? ISD::SETLT : ISD::SETULT); } if ((Cond == ISD::SETLT || Cond == ISD::SETULT) && C1 == MinVal) diff --git a/lib/Target/ARM/ARMTargetTransformInfo.cpp b/lib/Target/ARM/ARMTargetTransformInfo.cpp index 75247dfe352..25caa11b925 100644 --- a/lib/Target/ARM/ARMTargetTransformInfo.cpp +++ b/lib/Target/ARM/ARMTargetTransformInfo.cpp @@ -76,7 +76,7 @@ public: /// \name Scalar TTI Implementations /// @{ - + using TargetTransformInfo::getIntImmCost; virtual unsigned getIntImmCost(const APInt &Imm, Type *Ty) const LLVM_OVERRIDE; diff --git a/lib/Target/X86/X86TargetTransformInfo.cpp b/lib/Target/X86/X86TargetTransformInfo.cpp index da2b021da93..781be2fddd9 100644 --- a/lib/Target/X86/X86TargetTransformInfo.cpp +++ b/lib/Target/X86/X86TargetTransformInfo.cpp @@ -18,6 +18,7 @@ #include "X86.h" #include "X86TargetMachine.h" #include "llvm/Analysis/TargetTransformInfo.h" +#include "llvm/IR/IntrinsicInst.h" #include "llvm/Support/Debug.h" #include "llvm/Target/CostTable.h" #include "llvm/Target/TargetLowering.h" @@ -107,6 +108,14 @@ public: virtual unsigned getReductionCost(unsigned Opcode, Type *Ty, bool IsPairwiseForm) const LLVM_OVERRIDE; + virtual unsigned getIntImmCost(const APInt &Imm, + Type *Ty) const LLVM_OVERRIDE; + + virtual unsigned getIntImmCost(unsigned Opcode, const APInt &Imm, + Type *Ty) const LLVM_OVERRIDE; + virtual unsigned getIntImmCost(Intrinsic::ID IID, const APInt &Imm, + Type *Ty) const LLVM_OVERRIDE; + /// @} }; @@ -694,3 +703,89 @@ unsigned X86TTI::getReductionCost(unsigned Opcode, Type *ValTy, return TargetTransformInfo::getReductionCost(Opcode, ValTy, IsPairwise); } +unsigned X86TTI::getIntImmCost(const APInt &Imm, Type *Ty) const { + assert(Ty->isIntegerTy()); + + unsigned BitSize = Ty->getPrimitiveSizeInBits(); + if (BitSize == 0) + return ~0U; + + if (Imm.getBitWidth() <= 64 && + (isInt<32>(Imm.getSExtValue()) || isUInt<32>(Imm.getZExtValue()))) + return TCC_Basic; + else + return 2 * TCC_Basic; +} + +unsigned X86TTI::getIntImmCost(unsigned Opcode, const APInt &Imm, + Type *Ty) const { + assert(Ty->isIntegerTy()); + + unsigned BitSize = Ty->getPrimitiveSizeInBits(); + if (BitSize == 0) + return ~0U; + + switch (Opcode) { + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + case Instruction::UDiv: + case Instruction::SDiv: + case Instruction::URem: + case Instruction::SRem: + case Instruction::Shl: + case Instruction::LShr: + case Instruction::AShr: + case Instruction::And: + case Instruction::Or: + case Instruction::Xor: + case Instruction::ICmp: + if (Imm.getBitWidth() <= 64 && isInt<32>(Imm.getSExtValue())) + return TCC_Free; + else + return X86TTI::getIntImmCost(Imm, Ty); + case Instruction::Trunc: + case Instruction::ZExt: + case Instruction::SExt: + case Instruction::IntToPtr: + case Instruction::PtrToInt: + case Instruction::BitCast: + case Instruction::Call: + case Instruction::Select: + case Instruction::Ret: + case Instruction::Load: + case Instruction::Store: + return X86TTI::getIntImmCost(Imm, Ty); + } + return TargetTransformInfo::getIntImmCost(Opcode, Imm, Ty); +} + +unsigned X86TTI::getIntImmCost(Intrinsic::ID IID, const APInt &Imm, + Type *Ty) const { + assert(Ty->isIntegerTy()); + + unsigned BitSize = Ty->getPrimitiveSizeInBits(); + if (BitSize == 0) + return ~0U; + + switch (IID) { + default: return TargetTransformInfo::getIntImmCost(IID, Imm, Ty); + case Intrinsic::sadd_with_overflow: + case Intrinsic::uadd_with_overflow: + case Intrinsic::ssub_with_overflow: + case Intrinsic::usub_with_overflow: + case Intrinsic::smul_with_overflow: + case Intrinsic::umul_with_overflow: + if (Imm.getBitWidth() <= 64 && isInt<32>(Imm.getSExtValue())) + return TCC_Free; + else + return X86TTI::getIntImmCost(Imm, Ty); + case Intrinsic::experimental_stackmap: + case Intrinsic::experimental_patchpoint_void: + case Intrinsic::experimental_patchpoint_i64: + if (Imm.getBitWidth() <= 64 && isInt<64>(Imm.getSExtValue())) + return TCC_Free; + else + return X86TTI::getIntImmCost(Imm, Ty); + } +} diff --git a/lib/Transforms/Scalar/CMakeLists.txt b/lib/Transforms/Scalar/CMakeLists.txt index 0b2928677c3..8a29b0c48cb 100644 --- a/lib/Transforms/Scalar/CMakeLists.txt +++ b/lib/Transforms/Scalar/CMakeLists.txt @@ -1,6 +1,7 @@ add_llvm_library(LLVMScalarOpts ADCE.cpp CodeGenPrepare.cpp + ConstantHoisting.cpp ConstantProp.cpp CorrelatedValuePropagation.cpp DCE.cpp diff --git a/lib/Transforms/Scalar/CodeGenPrepare.cpp b/lib/Transforms/Scalar/CodeGenPrepare.cpp index 38f587b2cc8..6acbd5eaa14 100644 --- a/lib/Transforms/Scalar/CodeGenPrepare.cpp +++ b/lib/Transforms/Scalar/CodeGenPrepare.cpp @@ -240,7 +240,7 @@ bool CodeGenPrepare::runOnFunction(Function &F) { bool CodeGenPrepare::EliminateFallThrough(Function &F) { bool Changed = false; // Scan all of the blocks in the function, except for the entry block. - for (Function::iterator I = ++F.begin(), E = F.end(); I != E; ) { + for (Function::iterator I = llvm::next(F.begin()), E = F.end(); I != E; ) { BasicBlock *BB = I++; // If the destination block has a single pred, then this is a trivial // edge, just collapse it. @@ -276,7 +276,7 @@ bool CodeGenPrepare::EliminateFallThrough(Function &F) { bool CodeGenPrepare::EliminateMostlyEmptyBlocks(Function &F) { bool MadeChange = false; // Note that this intentionally skips the entry block. - for (Function::iterator I = ++F.begin(), E = F.end(); I != E; ) { + for (Function::iterator I = llvm::next(F.begin()), E = F.end(); I != E; ) { BasicBlock *BB = I++; // If this block doesn't end with an uncond branch, ignore it. diff --git a/lib/Transforms/Scalar/ConstantHoisting.cpp b/lib/Transforms/Scalar/ConstantHoisting.cpp new file mode 100644 index 00000000000..883385d3775 --- /dev/null +++ b/lib/Transforms/Scalar/ConstantHoisting.cpp @@ -0,0 +1,436 @@ +//===- ConstantHoisting.cpp - Prepare code for expensive constants --------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// This pass identifies expensive constants to hoist and coalesces them to +// better prepare it for SelectionDAG-based code generation. This works around +// the limitations of the basic-block-at-a-time approach. +// +// First it scans all instructions for integer constants and calculates its +// cost. If the constant can be folded into the instruction (the cost is +// TCC_Free) or the cost is just a simple operation (TCC_BASIC), then we don't +// consider it expensive and leave it alone. This is the default behavior and +// the default implementation of getIntImmCost will always return TCC_Free. +// +// If the cost is more than TCC_BASIC, then the integer constant can't be folded +// into the instruction and it might be beneficial to hoist the constant. +// Similar constants are coalesced to reduce register pressure and +// materialization code. +// +// When a constant is hoisted, it is also hidden behind a bitcast to force it to +// be live-out of the basic block. Otherwise the constant would be just +// duplicated and each basic block would have its own copy in the SelectionDAG. +// The SelectionDAG recognizes such constants as opaque and doesn't perform +// certain transformations on them, which would create a new expensive constant. +// +// This optimization is only applied to integer constants in instructions and +// simple (this means not nested) constant cast experessions. For example: +// %0 = load i64* inttoptr (i64 big_constant to i64*) +//===----------------------------------------------------------------------===// + +#define DEBUG_TYPE "consthoist" +#include "llvm/Transforms/Scalar.h" +#include "llvm/ADT/MapVector.h" +#include "llvm/ADT/SmallSet.h" +#include "llvm/ADT/Statistic.h" +#include "llvm/Analysis/TargetTransformInfo.h" +#include "llvm/IR/Constants.h" +#include "llvm/IR/Dominators.h" +#include "llvm/IR/IntrinsicInst.h" +#include "llvm/Pass.h" +#include "llvm/Support/CommandLine.h" +#include "llvm/Support/Debug.h" + +using namespace llvm; + +STATISTIC(NumConstantsHoisted, "Number of constants hoisted"); +STATISTIC(NumConstantsRebased, "Number of constants rebased"); + + +namespace { +typedef SmallVector ConstantUseListType; +struct ConstantCandidate { + unsigned CumulativeCost; + ConstantUseListType Uses; +}; + +struct ConstantInfo { + ConstantInt *BaseConstant; + struct RebasedConstantInfo { + ConstantInt *OriginalConstant; + Constant *Offset; + ConstantUseListType Uses; + }; + typedef SmallVector RebasedConstantListType; + RebasedConstantListType RebasedConstants; +}; + +class ConstantHoisting : public FunctionPass { + const TargetTransformInfo *TTI; + DominatorTree *DT; + + /// Keeps track of expensive constants found in the function. + typedef MapVector ConstantMapType; + ConstantMapType ConstantMap; + + /// These are the final constants we decided to hoist. + SmallVector Constants; +public: + static char ID; // Pass identification, replacement for typeid + ConstantHoisting() : FunctionPass(ID), TTI(0) { + initializeConstantHoistingPass(*PassRegistry::getPassRegistry()); + } + + bool runOnFunction(Function &F); + + const char *getPassName() const { return "Constant Hoisting"; } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesCFG(); + AU.addRequired(); + AU.addRequired(); + } + +private: + void CollectConstant(User *U, unsigned Opcode, Intrinsic::ID IID, + ConstantInt *C); + void CollectConstants(Instruction *I); + void CollectConstants(Function &F); + void FindAndMakeBaseConstant(ConstantMapType::iterator S, + ConstantMapType::iterator E); + void FindBaseConstants(); + Instruction *FindConstantInsertionPoint(Function &F, + const ConstantInfo &CI) const; + void EmitBaseConstants(Function &F, User *U, Instruction *Base, + Constant *Offset, ConstantInt *OriginalConstant); + bool EmitBaseConstants(Function &F); + bool OptimizeConstants(Function &F); +}; +} + +char ConstantHoisting::ID = 0; +INITIALIZE_PASS_BEGIN(ConstantHoisting, "consthoist", "Constant Hoisting", + false, false) +INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass) +INITIALIZE_AG_DEPENDENCY(TargetTransformInfo) +INITIALIZE_PASS_END(ConstantHoisting, "consthoist", "Constant Hoisting", + false, false) + +FunctionPass *llvm::createConstantHoistingPass() { + return new ConstantHoisting(); +} + +/// \brief Perform the constant hoisting optimization for the given function. +bool ConstantHoisting::runOnFunction(Function &F) { + DEBUG(dbgs() << "********** Constant Hoisting **********\n"); + DEBUG(dbgs() << "********** Function: " << F.getName() << '\n'); + + DT = &getAnalysis().getDomTree(); + TTI = &getAnalysis(); + + return OptimizeConstants(F); +} + +void ConstantHoisting::CollectConstant(User * U, unsigned Opcode, + Intrinsic::ID IID, ConstantInt *C) { + unsigned Cost; + if (Opcode) + Cost = TTI->getIntImmCost(Opcode, C->getValue(), C->getType()); + else + Cost = TTI->getIntImmCost(IID, C->getValue(), C->getType()); + + if (Cost > TargetTransformInfo::TCC_Basic) { + ConstantCandidate &CC = ConstantMap[C]; + CC.CumulativeCost += Cost; + CC.Uses.push_back(U); + } +} + +/// \brief Scan the instruction or constant expression for expensive integer +/// constants and record them in the constant map. +void ConstantHoisting::CollectConstants(Instruction *I) { + unsigned Opcode = 0; + Intrinsic::ID IID = Intrinsic::not_intrinsic; + if (IntrinsicInst *II = dyn_cast(I)) + IID = II->getIntrinsicID(); + else + Opcode = I->getOpcode(); + + // Scan all operands. + for (User::op_iterator O = I->op_begin(), E = I->op_end(); O != E; ++O) { + if (ConstantInt *C = dyn_cast(O)) { + CollectConstant(I, Opcode, IID, C); + continue; + } + if (ConstantExpr *CE = dyn_cast(O)) { + // We only handle constant cast expressions. + if (!CE->isCast()) + continue; + + if (ConstantInt *C = dyn_cast(CE->getOperand(0))) { + // Ignore the cast expression and use the opcode of the instruction. + CollectConstant(CE, Opcode, IID, C); + continue; + } + } + } +} + +/// \brief Collect all integer constants in the function that cannot be folded +/// into an instruction itself. +void ConstantHoisting::CollectConstants(Function &F) { + for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) + for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) + CollectConstants(I); +} + +/// \brief Compare function for sorting integer constants by type and by value +/// within a type in ConstantMaps. +static bool +ConstantMapLessThan(const std::pair &LHS, + const std::pair &RHS) { + if (LHS.first->getType() == RHS.first->getType()) + return LHS.first->getValue().ult(RHS.first->getValue()); + else + return LHS.first->getType()->getBitWidth() < + RHS.first->getType()->getBitWidth(); +} + +/// \brief Find the base constant within the given range and rebase all other +/// constants with respect to the base constant. +void ConstantHoisting::FindAndMakeBaseConstant(ConstantMapType::iterator S, + ConstantMapType::iterator E) { + ConstantMapType::iterator MaxCostItr = S; + unsigned NumUses = 0; + // Use the constant that has the maximum cost as base constant. + for (ConstantMapType::iterator I = S; I != E; ++I) { + NumUses += I->second.Uses.size(); + if (I->second.CumulativeCost > MaxCostItr->second.CumulativeCost) + MaxCostItr = I; + } + + // Don't hoist constants that have only one use. + if (NumUses <= 1) + return; + + ConstantInfo CI; + CI.BaseConstant = MaxCostItr->first; + Type *Ty = CI.BaseConstant->getType(); + // Rebase the constants with respect to the base constant. + for (ConstantMapType::iterator I = S; I != E; ++I) { + APInt Diff = I->first->getValue() - CI.BaseConstant->getValue(); + ConstantInfo::RebasedConstantInfo RCI; + RCI.OriginalConstant = I->first; + RCI.Offset = ConstantInt::get(Ty, Diff); + RCI.Uses = llvm_move(I->second.Uses); + CI.RebasedConstants.push_back(RCI); + } + Constants.push_back(CI); +} + +/// \brief Finds and combines constants that can be easily rematerialized with +/// an add from a common base constant. +void ConstantHoisting::FindBaseConstants() { + // Sort the constants by value and type. This invalidates the mapping. + std::sort(ConstantMap.begin(), ConstantMap.end(), ConstantMapLessThan); + + // Simple linear scan through the sorted constant map for viable merge + // candidates. + ConstantMapType::iterator MinValItr = ConstantMap.begin(); + for (ConstantMapType::iterator I = llvm::next(ConstantMap.begin()), + E = ConstantMap.end(); I != E; ++I) { + if (MinValItr->first->getType() == I->first->getType()) { + // Check if the constant is in range of an add with immediate. + APInt Diff = I->first->getValue() - MinValItr->first->getValue(); + if ((Diff.getBitWidth() <= 64) && + TTI->isLegalAddImmediate(Diff.getSExtValue())) + continue; + } + // We either have now a different constant type or the constant is not in + // range of an add with immediate anymore. + FindAndMakeBaseConstant(MinValItr, I); + // Start a new base constant search. + MinValItr = I; + } + // Finalize the last base constant search. + FindAndMakeBaseConstant(MinValItr, ConstantMap.end()); +} + +/// \brief Records the basic block of the instruction or all basic blocks of the +/// users of the constant expression. +static void CollectBasicBlocks(SmallPtrSet &BBs, Function &F, + User *U) { + if (Instruction *I = dyn_cast(U)) + BBs.insert(I->getParent()); + else if (ConstantExpr *CE = dyn_cast(U)) + // Find all users of this constant expression. + for (Value::use_iterator UU = CE->use_begin(), E = CE->use_end(); + UU != E; ++UU) + // Only record users that are instructions. We don't want to go down a + // nested constant expression chain. Also check if the instruction is even + // in the current function. + if (Instruction *I = dyn_cast(*UU)) + if(I->getParent()->getParent() == &F) + BBs.insert(I->getParent()); +} + +/// \brief Find an insertion point that dominates all uses. +Instruction *ConstantHoisting:: +FindConstantInsertionPoint(Function &F, const ConstantInfo &CI) const { + BasicBlock *Entry = &F.getEntryBlock(); + + // Collect all basic blocks. + SmallPtrSet BBs; + ConstantInfo::RebasedConstantListType::const_iterator RCI, RCE; + for (RCI = CI.RebasedConstants.begin(), RCE = CI.RebasedConstants.end(); + RCI != RCE; ++RCI) + for (SmallVectorImpl::const_iterator U = RCI->Uses.begin(), + E = RCI->Uses.end(); U != E; ++U) + CollectBasicBlocks(BBs, F, *U); + + if (BBs.count(Entry)) + return Entry->getFirstInsertionPt(); + + while (BBs.size() >= 2) { + BasicBlock *BB, *BB1, *BB2; + BB1 = *BBs.begin(); + BB2 = *llvm::next(BBs.begin()); + BB = DT->findNearestCommonDominator(BB1, BB2); + if (BB == Entry) + return Entry->getFirstInsertionPt(); + BBs.erase(BB1); + BBs.erase(BB2); + BBs.insert(BB); + } + assert((BBs.size() == 1) && "Expected only one element."); + return (*BBs.begin())->getFirstInsertionPt(); +} + +/// \brief Emit materialization code for all rebased constants and update their +/// users. +void ConstantHoisting::EmitBaseConstants(Function &F, User *U, + Instruction *Base, Constant *Offset, + ConstantInt *OriginalConstant) { + if (Instruction *I = dyn_cast(U)) { + Instruction *Mat = Base; + if (!Offset->isNullValue()) { + Mat = BinaryOperator::Create(Instruction::Add, Base, Offset, + "const_mat", I); + + // Use the same debug location as the instruction we are about to update. + Mat->setDebugLoc(I->getDebugLoc()); + + DEBUG(dbgs() << "Materialize constant (" << *Base->getOperand(0) + << " + " << *Offset << ") in BB " + << I->getParent()->getName() << '\n' << *Mat << '\n'); + } + DEBUG(dbgs() << "Update: " << *I << '\n'); + I->replaceUsesOfWith(OriginalConstant, Mat); + DEBUG(dbgs() << "To: " << *I << '\n'); + return; + } + assert(isa(U) && "Expected a ConstantExpr."); + ConstantExpr *CE = cast(U); + for (Value::use_iterator UU = CE->use_begin(), E = CE->use_end(); + UU != E; ++UU) { + // We only handel instructions here and won't walk down a ConstantExpr chain + // to replace all ConstExpr with instructions. + if (Instruction *I = dyn_cast(*UU)) { + // Only update constant expressions in the current function. + if (I->getParent()->getParent() != &F) + continue; + + Instruction *Mat = Base; + if (!Offset->isNullValue()) { + Mat = BinaryOperator::Create(Instruction::Add, Base, Offset, + "const_mat", I); + + // Use the same debug location as the instruction we are about to + // update. + Mat->setDebugLoc(I->getDebugLoc()); + + DEBUG(dbgs() << "Materialize constant (" << *Base->getOperand(0) + << " + " << *Offset << ") in BB " + << I->getParent()->getName() << '\n' << *Mat << '\n'); + } + Instruction *ICE = CE->getAsInstruction(); + ICE->replaceUsesOfWith(OriginalConstant, Mat); + ICE->insertBefore(I); + + // Use the same debug location as the instruction we are about to update. + ICE->setDebugLoc(I->getDebugLoc()); + + DEBUG(dbgs() << "Create instruction: " << *ICE << '\n'); + DEBUG(dbgs() << "Update: " << *I << '\n'); + I->replaceUsesOfWith(CE, ICE); + DEBUG(dbgs() << "To: " << *I << '\n'); + } + } +} + +/// \brief Hoist and hide the base constant behind a bitcast and emit +/// materialization code for derived constants. +bool ConstantHoisting::EmitBaseConstants(Function &F) { + bool MadeChange = false; + SmallVectorImpl::iterator CI, CE; + for (CI = Constants.begin(), CE = Constants.end(); CI != CE; ++CI) { + // Hoist and hide the base constant behind a bitcast. + Instruction *IP = FindConstantInsertionPoint(F, *CI); + IntegerType *Ty = CI->BaseConstant->getType(); + Instruction *Base = new BitCastInst(CI->BaseConstant, Ty, "const", IP); + DEBUG(dbgs() << "Hoist constant (" << *CI->BaseConstant << ") to BB " + << IP->getParent()->getName() << '\n'); + NumConstantsHoisted++; + + // Emit materialization code for all rebased constants. + ConstantInfo::RebasedConstantListType::iterator RCI, RCE; + for (RCI = CI->RebasedConstants.begin(), RCE = CI->RebasedConstants.end(); + RCI != RCE; ++RCI) { + NumConstantsRebased++; + for (SmallVectorImpl::iterator U = RCI->Uses.begin(), + E = RCI->Uses.end(); U != E; ++U) + EmitBaseConstants(F, *U, Base, RCI->Offset, RCI->OriginalConstant); + } + + // Use the same debug location as the last user of the constant. + assert(!Base->use_empty() && "The use list is empty!?"); + assert(isa(Base->use_back()) && + "All uses should be instructions."); + Base->setDebugLoc(cast(Base->use_back())->getDebugLoc()); + + // Correct for base constant, which we counted above too. + NumConstantsRebased--; + MadeChange = true; + } + return MadeChange; +} + +/// \brief Optimize expensive integer constants in the given function. +bool ConstantHoisting::OptimizeConstants(Function &F) { + bool MadeChange = false; + + // Collect all constant candidates. + CollectConstants(F); + + // There are no constants to worry about. + if (ConstantMap.empty()) + return MadeChange; + + // Combine constants that can be easily materialized with an add from a common + // base constant. + FindBaseConstants(); + + // Finaly hoist the base constant and emit materializating code for dependent + // constants. + MadeChange |= EmitBaseConstants(F); + + ConstantMap.clear(); + Constants.clear(); + + return MadeChange; +} diff --git a/lib/Transforms/Scalar/Scalar.cpp b/lib/Transforms/Scalar/Scalar.cpp index 6983d06b681..f774874cb47 100644 --- a/lib/Transforms/Scalar/Scalar.cpp +++ b/lib/Transforms/Scalar/Scalar.cpp @@ -30,6 +30,7 @@ void llvm::initializeScalarOpts(PassRegistry &Registry) { initializeADCEPass(Registry); initializeSampleProfileLoaderPass(Registry); initializeCodeGenPreparePass(Registry); + initializeConstantHoistingPass(Registry); initializeConstantPropagationPass(Registry); initializeCorrelatedValuePropagationPass(Registry); initializeDCEPass(Registry); diff --git a/test/CodeGen/ARM/memcpy-inline.ll b/test/CodeGen/ARM/memcpy-inline.ll index 946c63ed40c..14d84deea81 100644 --- a/test/CodeGen/ARM/memcpy-inline.ll +++ b/test/CodeGen/ARM/memcpy-inline.ll @@ -38,7 +38,8 @@ entry: define void @t2(i8* nocapture %C) nounwind { entry: ; CHECK-LABEL: t2: -; CHECK: ldr [[REG2:r[0-9]+]], [r1, #32] +; CHECK: movw [[REG2:r[0-9]+]], #16716 +; CHECK: movt [[REG2:r[0-9]+]], #72 ; CHECK: str [[REG2]], [r0, #32] ; CHECK: vld1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r1] ; CHECK: vst1.8 {d{{[0-9]+}}, d{{[0-9]+}}}, [r0] @@ -79,7 +80,8 @@ entry: ; CHECK: strb [[REG5]], [r0, #6] ; CHECK: movw [[REG6:r[0-9]+]], #21587 ; CHECK: strh [[REG6]], [r0, #4] -; CHECK: ldr [[REG7:r[0-9]+]], +; CHECK: movw [[REG7:r[0-9]+]], #18500 +; CHECK: movt [[REG7:r[0-9]+]], #22866 ; CHECK: str [[REG7]] tail call void @llvm.memcpy.p0i8.p0i8.i64(i8* %C, i8* getelementptr inbounds ([7 x i8]* @.str5, i64 0, i64 0), i64 7, i32 1, i1 false) ret void diff --git a/test/CodeGen/X86/large-constants.ll b/test/CodeGen/X86/large-constants.ll new file mode 100644 index 00000000000..157ecc4af66 --- /dev/null +++ b/test/CodeGen/X86/large-constants.ll @@ -0,0 +1,67 @@ +; RUN: llc < %s -mtriple=x86_64-darwin -mcpu=corei7 | grep movabsq | count 3 + +define i64 @constant_hoisting(i64 %o0, i64 %o1, i64 %o2, i64 %o3, i64 %o4, i64 %o5) { +entry: + %l0 = and i64 %o0, -281474976710654 + %c0 = icmp ne i64 %l0, 0 + br i1 %c0, label %fail, label %bb1 + +bb1: + %l1 = and i64 %o1, -281474976710654 + %c1 = icmp ne i64 %l1, 0 + br i1 %c1, label %fail, label %bb2 + +bb2: + %l2 = and i64 %o2, -281474976710654 + %c2 = icmp ne i64 %l2, 0 + br i1 %c2, label %fail, label %bb3 + +bb3: + %l3 = and i64 %o3, -281474976710654 + %c3 = icmp ne i64 %l3, 0 + br i1 %c3, label %fail, label %bb4 + +bb4: + %l4 = and i64 %o4, -281474976710653 + %c4 = icmp ne i64 %l4, 0 + br i1 %c4, label %fail, label %bb5 + +bb5: + %l5 = and i64 %o5, -281474976710652 + %c5 = icmp ne i64 %l5, 0 + br i1 %c5, label %fail, label %bb6 + +bb6: + ret i64 %l5 + +fail: + ret i64 -1 +} + +define void @constant_expressions() { +entry: + %0 = load i64* inttoptr (i64 add (i64 51250129900, i64 0) to i64*) + %1 = load i64* inttoptr (i64 add (i64 51250129900, i64 8) to i64*) + %2 = load i64* inttoptr (i64 add (i64 51250129900, i64 16) to i64*) + %3 = load i64* inttoptr (i64 add (i64 51250129900, i64 24) to i64*) + %4 = add i64 %0, %1 + %5 = add i64 %2, %3 + %6 = add i64 %4, %5 + store i64 %6, i64* inttoptr (i64 add (i64 51250129900, i64 0) to i64*) + ret void +} + + +define void @constant_expressions2() { +entry: + %0 = load i64* inttoptr (i64 51250129900 to i64*) + %1 = load i64* inttoptr (i64 51250129908 to i64*) + %2 = load i64* inttoptr (i64 51250129916 to i64*) + %3 = load i64* inttoptr (i64 51250129924 to i64*) + %4 = add i64 %0, %1 + %5 = add i64 %2, %3 + %6 = add i64 %4, %5 + store i64 %6, i64* inttoptr (i64 51250129900 to i64*) + ret void +} + -- 2.34.1