X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FCodeGen%2FCodeGenPrepare.cpp;h=948fddc6ed8d766bd7eeb473d399a22144cd5f9b;hb=25529b337f75a4b9b174592e2c95136e781bd824;hp=85734f715c9a170359648845b91af64312334219;hpb=8677f2ff9acf317461987b439ede693f01baa5ec;p=oota-llvm.git diff --git a/lib/CodeGen/CodeGenPrepare.cpp b/lib/CodeGen/CodeGenPrepare.cpp index 85734f715c9..948fddc6ed8 100644 --- a/lib/CodeGen/CodeGenPrepare.cpp +++ b/lib/CodeGen/CodeGenPrepare.cpp @@ -151,19 +151,8 @@ typedef DenseMap InstrToOrigTy; } char CodeGenPrepare::ID = 0; -static void *initializeCodeGenPreparePassOnce(PassRegistry &Registry) { - initializeTargetLibraryInfoPass(Registry); - PassInfo *PI = new PassInfo( - "Optimize for code generation", "codegenprepare", &CodeGenPrepare::ID, - PassInfo::NormalCtor_t(callDefaultCtor), false, false, - PassInfo::TargetMachineCtor_t(callTargetMachineCtor)); - Registry.registerPass(*PI, true); - return PI; -} - -void llvm::initializeCodeGenPreparePass(PassRegistry &Registry) { - CALL_ONCE_INITIALIZATION(initializeCodeGenPreparePassOnce) -} +INITIALIZE_TM_PASS(CodeGenPrepare, "codegenprepare", + "Optimize for code generation", false, false) FunctionPass *llvm::createCodeGenPreparePass(const TargetMachine *TM) { return new CodeGenPrepare(TM); @@ -179,7 +168,8 @@ bool CodeGenPrepare::runOnFunction(Function &F) { PromotedInsts.clear(); ModifiedDT = false; - if (TM) TLI = TM->getTargetLowering(); + if (TM) + TLI = TM->getSubtargetImpl()->getTargetLowering(); TLInfo = &getAnalysis(); DominatorTreeWrapperPass *DTWP = getAnalysisIfAvailable(); @@ -634,7 +624,7 @@ static bool OptimizeCmpExpression(CmpInst *CI) { /// 1. Truncate instruction /// 2. And instruction and the imm is a mask of the low bits: /// imm & (imm+1) == 0 -bool isExtractBitsCandidateUse(Instruction *User) { +static bool isExtractBitsCandidateUse(Instruction *User) { if (!isa(User)) { if (User->getOpcode() != Instruction::And || !isa(User->getOperand(1))) @@ -650,7 +640,7 @@ bool isExtractBitsCandidateUse(Instruction *User) { /// SinkShiftAndTruncate - sink both shift and truncate instruction /// to the use of truncate's BB. -bool +static bool SinkShiftAndTruncate(BinaryOperator *ShiftI, Instruction *User, ConstantInt *CI, DenseMap &InsertedShifts, const TargetLowering &TLI) { @@ -673,10 +663,13 @@ SinkShiftAndTruncate(BinaryOperator *ShiftI, Instruction *User, ConstantInt *CI, if (!ISDOpcode) continue; - // If the use is actually a legal node, there will not be an implicit - // truncate. + // If the use is actually a legal node, there will not be an + // implicit truncate. + // FIXME: always querying the result type is just an + // approximation; some nodes' legality is determined by the + // operand or other means. There's no good way to find out though. if (TLI.isOperationLegalOrCustom(ISDOpcode, - EVT::getEVT(TruncUser->getType()))) + EVT::getEVT(TruncUser->getType(), true))) continue; // Don't bother for PHI nodes. @@ -870,242 +863,6 @@ bool CodeGenPrepare::OptimizeCallInst(CallInst *CI) { } return true; } - // Lower all uses of llvm.safe.[us]{div|rem}... - if (II && - (II->getIntrinsicID() == Intrinsic::safe_sdiv || - II->getIntrinsicID() == Intrinsic::safe_udiv || - II->getIntrinsicID() == Intrinsic::safe_srem || - II->getIntrinsicID() == Intrinsic::safe_urem)) { - // Given - // result_struct = type {iN, i1} - // %R = call result_struct llvm.safe.sdiv.iN(iN %x, iN %y) - // Expand it to actual IR, which produces result to the same variable %R. - // First element of the result %R.1 is the result of division, second - // element shows whether the division was correct or not. - // If %y is 0, %R.1 is 0, %R.2 is 1. (1) - // If %x is minSignedValue and %y is -1, %R.1 is %x, %R.2 is 1. (2) - // In other cases %R.1 is (sdiv %x, %y), %R.2 is 0. (3) - // - // Similar applies to srem, udiv, and urem builtins, except that in unsigned - // variants we don't check condition (2). - - bool IsSigned; - BinaryOperator::BinaryOps Op; - switch (II->getIntrinsicID()) { - case Intrinsic::safe_sdiv: - IsSigned = true; - Op = Instruction::SDiv; - break; - case Intrinsic::safe_udiv: - IsSigned = false; - Op = Instruction::UDiv; - break; - case Intrinsic::safe_srem: - IsSigned = true; - Op = Instruction::SRem; - break; - case Intrinsic::safe_urem: - IsSigned = false; - Op = Instruction::URem; - break; - default: - llvm_unreachable("Only Div/Rem intrinsics are handled here."); - } - - Value *LHS = II->getOperand(0), *RHS = II->getOperand(1); - bool DivWellDefined = TLI && TLI->isDivWellDefined(); - - bool ResultNeeded[2] = {false, false}; - SmallVector ResultsUsers[2]; - bool BadCase = false; - for (User *U: II->users()) { - ExtractValueInst *EVI = dyn_cast(U); - if (!EVI || EVI->getNumIndices() > 1 || EVI->getIndices()[0] > 1) { - BadCase = true; - break; - } - ResultNeeded[EVI->getIndices()[0]] = true; - ResultsUsers[EVI->getIndices()[0]].push_back(U); - } - // Behave conservatively, if there is an unusual user of the results. - if (BadCase) - ResultNeeded[0] = ResultNeeded[1] = true; - - // Early exit if non of the results is ever used. - if (!ResultNeeded[0] && !ResultNeeded[1]) { - II->eraseFromParent(); - return true; - } - - // Early exit if the second result (flag) isn't used and target - // div-instruction computes exactly what we want to get as the first result - // and never traps. - if (ResultNeeded[0] && !ResultNeeded[1] && DivWellDefined) { - BinaryOperator *Div = BinaryOperator::Create(Op, LHS, RHS); - Div->insertAfter(II); - for (User *U: ResultsUsers[0]) { - Instruction *UserInst = dyn_cast(U); - assert(UserInst && "Unexpected null-instruction"); - UserInst->replaceAllUsesWith(Div); - UserInst->eraseFromParent(); - } - II->eraseFromParent(); - CurInstIterator = Div; - ModifiedDT = true; - return true; - } - - Value *MinusOne = Constant::getAllOnesValue(LHS->getType()); - Value *Zero = Constant::getNullValue(LHS->getType()); - - // Split the original BB and create other basic blocks that will be used - // for checks. - BasicBlock *StartBB = II->getParent(); - BasicBlock::iterator SplitPt = ++(BasicBlock::iterator(II)); - BasicBlock *NextBB = StartBB->splitBasicBlock(SplitPt, "div.end"); - - BasicBlock *DivByZeroBB; - DivByZeroBB = BasicBlock::Create(II->getContext(), "div.divz", - NextBB->getParent(), NextBB); - BranchInst::Create(NextBB, DivByZeroBB); - BasicBlock *DivBB = BasicBlock::Create(II->getContext(), "div.div", - NextBB->getParent(), NextBB); - BranchInst::Create(NextBB, DivBB); - - // For signed variants, check the condition (2): - // LHS == SignedMinValue, RHS == -1. - Value *CmpMinusOne; - Value *CmpMinValue; - BasicBlock *ChkDivMinBB; - BasicBlock *DivMinBB; - Value *MinValue; - if (IsSigned) { - APInt SignedMinValue = - APInt::getSignedMinValue(LHS->getType()->getPrimitiveSizeInBits()); - MinValue = Constant::getIntegerValue(LHS->getType(), SignedMinValue); - ChkDivMinBB = BasicBlock::Create(II->getContext(), "div.chkdivmin", - NextBB->getParent(), NextBB); - BranchInst::Create(NextBB, ChkDivMinBB); - DivMinBB = BasicBlock::Create(II->getContext(), "div.divmin", - NextBB->getParent(), NextBB); - BranchInst::Create(NextBB, DivMinBB); - CmpMinusOne = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ, - RHS, MinusOne, "cmp.rhs.minus.one", - ChkDivMinBB->getTerminator()); - CmpMinValue = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ, - LHS, MinValue, "cmp.lhs.signed.min", - ChkDivMinBB->getTerminator()); - BinaryOperator *CmpSignedOvf = BinaryOperator::Create(Instruction::And, - CmpMinusOne, - CmpMinValue); - // Here we're interested in the case when both %x is TMin and %y is -1. - // In this case the result will overflow. - // If that's not the case, we can perform usual division. These blocks - // will be inserted after DivByZero, so the division will be safe. - CmpSignedOvf->insertBefore(ChkDivMinBB->getTerminator()); - BranchInst::Create(DivMinBB, DivBB, CmpSignedOvf, - ChkDivMinBB->getTerminator()); - ChkDivMinBB->getTerminator()->eraseFromParent(); - } - - // Check the condition (1): - // RHS == 0. - Value *CmpDivZero = CmpInst::Create(Instruction::ICmp, CmpInst::ICMP_EQ, - RHS, Zero, "cmp.rhs.zero", - StartBB->getTerminator()); - - // If RHS != 0, we want to check condition (2) in signed case, or proceed - // to usual division in unsigned case. - BranchInst::Create(DivByZeroBB, IsSigned ? ChkDivMinBB : DivBB, CmpDivZero, - StartBB->getTerminator()); - StartBB->getTerminator()->eraseFromParent(); - - // At the moment we have all the control flow created. We just need to - // insert DIV and PHI (if needed) to get the result value. - Instruction *DivRes, *FlagRes; - Instruction *InsPoint = nullptr; - if (ResultNeeded[0]) { - BinaryOperator *Div = BinaryOperator::Create(Op, LHS, RHS); - if (DivWellDefined) { - // The result value is the result of DIV operation placed right at the - // original place of the intrinsic. - Div->insertAfter(II); - DivRes = Div; - } else { - // The result is a PHI-node. - Div->insertBefore(DivBB->getTerminator()); - PHINode *DivResPN = - PHINode::Create(LHS->getType(), IsSigned ? 3 : 2, "div.res.phi", - NextBB->begin()); - DivResPN->addIncoming(Div, DivBB); - DivResPN->addIncoming(Zero, DivByZeroBB); - if (IsSigned) - DivResPN->addIncoming(MinValue, DivMinBB); - DivRes = DivResPN; - InsPoint = DivResPN; - } - } - - // Prepare a value for the second result (flag) if it is needed. - if (ResultNeeded[1]) { - Type *FlagTy = II->getType()->getStructElementType(1); - PHINode *FlagResPN = - PHINode::Create(FlagTy, IsSigned ? 3 : 2, "div.flag.phi", - NextBB->begin()); - FlagResPN->addIncoming(Constant::getNullValue(FlagTy), DivBB); - FlagResPN->addIncoming(Constant::getAllOnesValue(FlagTy), DivByZeroBB); - if (IsSigned) - FlagResPN->addIncoming(Constant::getAllOnesValue(FlagTy), DivMinBB); - FlagRes = FlagResPN; - if (!InsPoint) - InsPoint = FlagRes; - } - - // If possible, propagate the results to the user. Otherwise, create alloca, - // and create a struct with the results on stack. - if (!BadCase) { - if (ResultNeeded[0]) { - for (User *U: ResultsUsers[0]) { - Instruction *UserInst = dyn_cast(U); - assert(UserInst && "Unexpected null-instruction"); - UserInst->replaceAllUsesWith(DivRes); - UserInst->eraseFromParent(); - } - } - if (ResultNeeded[1]) { - for (User *FlagU: ResultsUsers[1]) { - Instruction *FlagUInst = dyn_cast(FlagU); - FlagUInst->replaceAllUsesWith(FlagRes); - FlagUInst->eraseFromParent(); - } - } - } else { - // Create alloca, store our new values to it, and then load the final - // result from it. - Constant *Idx0 = ConstantInt::get(Type::getInt32Ty(II->getContext()), 0); - Constant *Idx1 = ConstantInt::get(Type::getInt32Ty(II->getContext()), 1); - Value *Idxs_DivRes[2] = {Idx0, Idx0}; - Value *Idxs_FlagRes[2] = {Idx0, Idx1}; - Value *NewRes = new llvm::AllocaInst(II->getType(), 0, "div.res.ptr", II); - Instruction *ResDivAddr = GetElementPtrInst::Create(NewRes, Idxs_DivRes); - Instruction *ResFlagAddr = - GetElementPtrInst::Create(NewRes, Idxs_FlagRes); - ResDivAddr->insertAfter(InsPoint); - ResFlagAddr->insertAfter(ResDivAddr); - StoreInst *StoreResDiv = new StoreInst(DivRes, ResDivAddr); - StoreInst *StoreResFlag = new StoreInst(FlagRes, ResFlagAddr); - StoreResDiv->insertAfter(ResFlagAddr); - StoreResFlag->insertAfter(StoreResDiv); - LoadInst *LoadRes = new LoadInst(NewRes, "div.res"); - LoadRes->insertAfter(StoreResFlag); - II->replaceAllUsesWith(LoadRes); - } - - II->eraseFromParent(); - CurInstIterator = StartBB->end(); - ModifiedDT = true; - return true; - } if (II && TLI) { SmallVector PtrOps; @@ -1314,8 +1071,11 @@ void ExtAddrMode::print(raw_ostream &OS) const { NeedPlus = true; } - if (BaseOffs) - OS << (NeedPlus ? " + " : "") << BaseOffs, NeedPlus = true; + if (BaseOffs) { + OS << (NeedPlus ? " + " : "") + << BaseOffs; + NeedPlus = true; + } if (BaseReg) { OS << (NeedPlus ? " + " : "") @@ -1876,6 +1636,7 @@ bool AddressingModeMatcher::MatchScaledValue(Value *ScaleReg, int64_t Scale, static bool MightBeFoldableInst(Instruction *I) { switch (I->getOpcode()) { case Instruction::BitCast: + case Instruction::AddrSpaceCast: // Don't touch identity bitcasts. if (I->getType() == I->getOperand(0)->getType()) return false; @@ -2230,6 +1991,7 @@ bool AddressingModeMatcher::MatchOperationAddr(User *AddrInst, unsigned Opcode, return MatchAddr(AddrInst->getOperand(0), Depth); return false; case Instruction::BitCast: + case Instruction::AddrSpaceCast: // BitCast is always a noop, and we can handle it as long as it is // int->int or pointer->pointer (we don't want int<->fp or something). if ((AddrInst->getOperand(0)->getType()->isPointerTy() || @@ -2278,7 +2040,8 @@ bool AddressingModeMatcher::MatchOperationAddr(User *AddrInst, unsigned Opcode, case Instruction::Shl: { // Can only handle X*C and X << C. ConstantInt *RHS = dyn_cast(AddrInst->getOperand(1)); - if (!RHS) return false; + if (!RHS) + return false; int64_t Scale = RHS->getSExtValue(); if (Opcode == Instruction::Shl) Scale = 1LL << Scale; @@ -2372,8 +2135,11 @@ bool AddressingModeMatcher::MatchOperationAddr(User *AddrInst, unsigned Opcode, return true; } case Instruction::SExt: { + Instruction *SExt = dyn_cast(AddrInst); + if (!SExt) + return false; + // Try to move this sext out of the way of the addressing mode. - Instruction *SExt = cast(AddrInst); // Ask for a method for doing so. TypePromotionHelper::Action TPH = TypePromotionHelper::getAction( SExt, InsertedTruncs, TLI, PromotedInsts); @@ -2835,7 +2601,7 @@ bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr, Value *&SunkAddr = SunkAddrs[Addr]; if (SunkAddr) { DEBUG(dbgs() << "CGP: Reusing nonlocal addrmode: " << AddrMode << " for " - << *MemoryInst); + << *MemoryInst << "\n"); if (SunkAddr->getType() != Addr->getType()) SunkAddr = Builder.CreateBitCast(SunkAddr, Addr->getType()); } else if (AddrSinkUsingGEPs || (!AddrSinkUsingGEPs.getNumOccurrences() && @@ -2843,7 +2609,7 @@ bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr, // By default, we use the GEP-based method when AA is used later. This // prevents new inttoptr/ptrtoint pairs from degrading AA capabilities. DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for " - << *MemoryInst); + << *MemoryInst << "\n"); Type *IntPtrTy = TLI->getDataLayout()->getIntPtrType(Addr->getType()); Value *ResultPtr = nullptr, *ResultIndex = nullptr; @@ -2961,7 +2727,7 @@ bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr, } } else { DEBUG(dbgs() << "CGP: SINKING nonlocal addrmode: " << AddrMode << " for " - << *MemoryInst); + << *MemoryInst << "\n"); Type *IntPtrTy = TLI->getDataLayout()->getIntPtrType(Addr->getType()); Value *Result = nullptr; @@ -2995,7 +2761,7 @@ bool CodeGenPrepare::OptimizeMemoryInst(Instruction *MemoryInst, Value *Addr, // the original IR value was tossed in favor of a constant back when // the AddrMode was created we need to bail out gracefully if widths // do not match instead of extending it. - Instruction *I = dyn_cast(Result); + Instruction *I = dyn_cast_or_null(Result); if (I && (Result != AddrMode.BaseReg)) I->eraseFromParent(); return false; @@ -3470,7 +3236,12 @@ bool CodeGenPrepare::PlaceDbgValues(Function &F) { for (BasicBlock::iterator BI = I->begin(), BE = I->end(); BI != BE;) { Instruction *Insn = BI; ++BI; DbgValueInst *DVI = dyn_cast(Insn); - if (!DVI) { + // Leave dbg.values that refer to an alloca alone. These + // instrinsics describe the address of a variable (= the alloca) + // being taken. They should not be moved next to the alloca + // (and to the beginning of the scope), but rather stay close to + // where said address is used. + if (!DVI || (DVI->getValue() && isa(DVI->getValue()))) { PrevNonDbgInst = Insn; continue; }