CbC/CbC_llvm: lib/IR/BasicBlock.cpp comparison

comparison lib/IR/BasicBlock.cpp @ 147:c2174574ed3a

LLVM 10

author	Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date	Wed, 14 Aug 2019 16:55:33 +0900
parents	3a76565eade5
children

comparison

equal deleted inserted replaced

-:3a76565eade5
+:c2174574ed3a
 //===-- BasicBlock.cpp - Implement BasicBlock related methods -------------===//
 //
-//                     The LLVM Compiler Infrastructure
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-//
+// See https://llvm.org/LICENSE.txt for license information.
-// This file is distributed under the University of Illinois Open Source
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the BasicBlock class for the IR library.
 //
 void BasicBlock::setParent(Function *parent) {
 // Set Parent=parent, updating instruction symtab entries as appropriate.
 InstList.setSymTabObject(&Parent, parent);
 }
+iterator_range<filter_iterator<BasicBlock::const_iterator,
+std::function<bool(const Instruction &)>>>
+BasicBlock::instructionsWithoutDebug() const {
+std::function<bool(const Instruction &)> Fn = [](const Instruction &I) {
+return !isa<DbgInfoIntrinsic>(I);
+};
+return make_filter_range(*this, Fn);
+}
+iterator_range<filter_iterator<BasicBlock::iterator,
+std::function<bool(Instruction &)>>>
+BasicBlock::instructionsWithoutDebug() {
+std::function<bool(Instruction &)> Fn = [](Instruction &I) {
+return !isa<DbgInfoIntrinsic>(I);
+};
+return make_filter_range(*this, Fn);
+}
 void BasicBlock::removeFromParent() {
 getParent()->getBasicBlockList().remove(getIterator());
 }
 iplist<BasicBlock>::iterator BasicBlock::eraseFromParent() {
 const Module *BasicBlock::getModule() const {
 return getParent()->getParent();
 }
-const TerminatorInst *BasicBlock::getTerminator() const {
+const Instruction *BasicBlock::getTerminator() const {
-if (InstList.empty()) return nullptr;
+if (InstList.empty() || !InstList.back().isTerminator())
-return dyn_cast<TerminatorInst>(&InstList.back());
+return nullptr;
+return &InstList.back();
 }
 const CallInst *BasicBlock::getTerminatingMustTailCall() const {
 if (InstList.empty())
 return nullptr;
 const Instruction* BasicBlock::getFirstNonPHIOrDbgOrLifetime() const {
 for (const Instruction &I : *this) {
 if (isa<PHINode>(I) || isa<DbgInfoIntrinsic>(I))
 continue;
-if (auto *II = dyn_cast<IntrinsicInst>(&I))
+if (I.isLifetimeStartOrEnd())
-if (II->getIntrinsicID() == Intrinsic::lifetime_start ||
+continue;
-II->getIntrinsicID() == Intrinsic::lifetime_end)
-continue;
 return &I;
 }
 return nullptr;
 }
 // This is OK.
 }
 return PredBB;
 }
+bool BasicBlock::hasNPredecessors(unsigned N) const {
+return hasNItems(pred_begin(this), pred_end(this), N);
+}
+bool BasicBlock::hasNPredecessorsOrMore(unsigned N) const {
+return hasNItemsOrMore(pred_begin(this), pred_end(this), N);
+}
 const BasicBlock *BasicBlock::getSingleSuccessor() const {
 succ_const_iterator SI = succ_begin(this), E = succ_end(this);
 if (SI == E) return nullptr; // no successors
 const BasicBlock *TheSucc = *SI;
 ++SI;
 /// actually not used to update the Predecessor list, but is actually used to
 /// update the PHI nodes that reside in the block.  Note that this should be
 /// called while the predecessor still refers to this block.
 ///
 void BasicBlock::removePredecessor(BasicBlock *Pred,
-bool DontDeleteUselessPHIs) {
+bool KeepOneInputPHIs) {
 assert((hasNUsesOrMore(16)||// Reduce cost of this assertion for complex CFGs.
 find(pred_begin(this), pred_end(this), Pred) != pred_end(this)) &&
 "removePredecessor: BB is not a predecessor!");
 if (InstList.empty()) return;
 // Disable PHI elimination!
 if (this == Other) max_idx = 3;
 }
 // <= Two predecessors BEFORE I remove one?
-if (max_idx <= 2 && !DontDeleteUselessPHIs) {
+if (max_idx <= 2 && !KeepOneInputPHIs) {
 // Yup, loop through and nuke the PHI nodes
 while (PHINode *PN = dyn_cast<PHINode>(&front())) {
 // Remove the predecessor first.
-PN->removeIncomingValue(Pred, !DontDeleteUselessPHIs);
+PN->removeIncomingValue(Pred, !KeepOneInputPHIs);
 // If the PHI _HAD_ two uses, replace PHI node with its now *single* value
 if (max_idx == 2) {
 if (PN->getIncomingValue(0) != PN)
 PN->replaceAllUsesWith(PN->getIncomingValue(0));
 ++II;
 PN->removeIncomingValue(Pred, false);
 // If all incoming values to the Phi are the same, we can replace the Phi
 // with that value.
 Value* PNV = nullptr;
-if (!DontDeleteUselessPHIs && (PNV = PN->hasConstantValue()))
+if (!KeepOneInputPHIs && (PNV = PN->hasConstantValue()))
 if (PNV != PN) {
 PN->replaceAllUsesWith(PNV);
 PN->eraseFromParent();
 }
 }
 // If the block has no successors, there can be no instructions to hoist.
 assert(Term->getNumSuccessors() > 0);
 // Instructions should not be hoisted across exception handling boundaries.
-return !Term->isExceptional();
+return !Term->isExceptionalTerminator();
 }
 /// This splits a basic block into two at the specified
 /// instruction.  Note that all instructions BEFORE the specified iterator stay
 /// as part of the original basic block, an unconditional branch is added to
 BI->setDebugLoc(Loc);
 // Now we must loop through all of the successors of the New block (which
 // _were_ the successors of the 'this' block), and update any PHI nodes in
 // successors.  If there were PHI nodes in the successors, then they need to
-// know that incoming branches will be from New, not from Old.
+// know that incoming branches will be from New, not from Old (this).
 //
-for (succ_iterator I = succ_begin(New), E = succ_end(New); I != E; ++I) {
+New->replaceSuccessorsPhiUsesWith(this, New);
-// Loop over any phi nodes in the basic block, updating the BB field of
-// incoming values...
-BasicBlock *Successor = *I;
-for (auto &PN : Successor->phis()) {
-int Idx = PN.getBasicBlockIndex(this);
-while (Idx != -1) {
-PN.setIncomingBlock((unsigned)Idx, New);
-Idx = PN.getBasicBlockIndex(this);
-}
-}
-}
 return New;
 }
-void BasicBlock::replaceSuccessorsPhiUsesWith(BasicBlock *New) {
+void BasicBlock::replacePhiUsesWith(BasicBlock *Old, BasicBlock *New) {
-TerminatorInst *TI = getTerminator();
+// N.B. This might not be a complete BasicBlock, so don't assume
+// that it ends with a non-phi instruction.
+for (iterator II = begin(), IE = end(); II != IE; ++II) {
+PHINode *PN = dyn_cast<PHINode>(II);
+if (!PN)
+break;
+PN->replaceIncomingBlockWith(Old, New);
+}
+}
+void BasicBlock::replaceSuccessorsPhiUsesWith(BasicBlock *Old,
+BasicBlock *New) {
+Instruction *TI = getTerminator();
 if (!TI)
 // Cope with being called on a BasicBlock that doesn't have a terminator
 // yet. Clang's CodeGenFunction::EmitReturnBlock() likes to do this.
 return;
-for (BasicBlock *Succ : TI->successors()) {
+llvm::for_each(successors(TI), [Old, New](BasicBlock *Succ) {
-// N.B. Succ might not be a complete BasicBlock, so don't assume
+Succ->replacePhiUsesWith(Old, New);
-// that it ends with a non-phi instruction.
+});
-for (iterator II = Succ->begin(), IE = Succ->end(); II != IE; ++II) {
+}
-PHINode *PN = dyn_cast<PHINode>(II);
-if (!PN)
+void BasicBlock::replaceSuccessorsPhiUsesWith(BasicBlock *New) {
-break;
+this->replaceSuccessorsPhiUsesWith(this, New);
-int i;
-while ((i = PN->getBasicBlockIndex(this)) >= 0)
-PN->setIncomingBlock(i, New);
-}
-}
 }
 /// Return true if this basic block is a landing pad. I.e., it's
 /// the destination of the 'unwind' edge of an invoke instruction.
 bool BasicBlock::isLandingPad() const {
 const LandingPadInst *BasicBlock::getLandingPadInst() const {
 return dyn_cast<LandingPadInst>(getFirstNonPHI());
 }
 Optional<uint64_t> BasicBlock::getIrrLoopHeaderWeight() const {
-const TerminatorInst *TI = getTerminator();
+const Instruction *TI = getTerminator();
 if (MDNode *MDIrrLoopHeader =
 TI->getMetadata(LLVMContext::MD_irr_loop)) {
 MDString *MDName = cast<MDString>(MDIrrLoopHeader->getOperand(0));
 if (MDName->getString().equals("loop_header_weight")) {
 auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
 return Optional<uint64_t>(CI->getValue().getZExtValue());
 }
 }
 return Optional<uint64_t>();
 }
+BasicBlock::iterator llvm::skipDebugIntrinsics(BasicBlock::iterator It) {
+while (isa<DbgInfoIntrinsic>(It))
+++It;
+return It;
+}

Mercurial > hg > CbC > CbC_llvm

comparison lib/IR/BasicBlock.cpp @ 147:c2174574ed3a