mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-22 18:54:02 +01:00
2f903fe2ac
Updated to use DenseMap::insert instead of [] operator for insertion, to avoid a crash caused by epoch checks. This reverts commit 2b85de438326f9d27bc96dc934ec98b98abdb337. llvm-svn: 357257
112 lines
4.4 KiB
C++
112 lines
4.4 KiB
C++
//===- OrderedBasicBlock.cpp --------------------------------- -*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the OrderedBasicBlock class. OrderedBasicBlock
|
|
// maintains an interface where clients can query if one instruction comes
|
|
// before another in a BasicBlock. Since BasicBlock currently lacks a reliable
|
|
// way to query relative position between instructions one can use
|
|
// OrderedBasicBlock to do such queries. OrderedBasicBlock is lazily built on a
|
|
// source BasicBlock and maintains an internal Instruction -> Position map. A
|
|
// OrderedBasicBlock instance should be discarded whenever the source
|
|
// BasicBlock changes.
|
|
//
|
|
// It's currently used by the CaptureTracker in order to find relative
|
|
// positions of a pair of instructions inside a BasicBlock.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Analysis/OrderedBasicBlock.h"
|
|
#include "llvm/IR/Instruction.h"
|
|
using namespace llvm;
|
|
|
|
OrderedBasicBlock::OrderedBasicBlock(const BasicBlock *BasicB)
|
|
: NextInstPos(0), BB(BasicB) {
|
|
LastInstFound = BB->end();
|
|
}
|
|
|
|
/// Given no cached results, find if \p A comes before \p B in \p BB.
|
|
/// Cache and number out instruction while walking \p BB.
|
|
bool OrderedBasicBlock::comesBefore(const Instruction *A,
|
|
const Instruction *B) {
|
|
const Instruction *Inst = nullptr;
|
|
assert(!(LastInstFound == BB->end() && NextInstPos != 0) &&
|
|
"Instruction supposed to be in NumberedInsts");
|
|
assert(A->getParent() == BB && "Instruction supposed to be in the block!");
|
|
assert(B->getParent() == BB && "Instruction supposed to be in the block!");
|
|
|
|
// Start the search with the instruction found in the last lookup round.
|
|
auto II = BB->begin();
|
|
auto IE = BB->end();
|
|
if (LastInstFound != IE)
|
|
II = std::next(LastInstFound);
|
|
|
|
// Number all instructions up to the point where we find 'A' or 'B'.
|
|
for (; II != IE; ++II) {
|
|
Inst = cast<Instruction>(II);
|
|
NumberedInsts[Inst] = NextInstPos++;
|
|
if (Inst == A || Inst == B)
|
|
break;
|
|
}
|
|
|
|
assert(II != IE && "Instruction not found?");
|
|
assert((Inst == A || Inst == B) && "Should find A or B");
|
|
LastInstFound = II;
|
|
return Inst != B;
|
|
}
|
|
|
|
/// Find out whether \p A dominates \p B, meaning whether \p A
|
|
/// comes before \p B in \p BB. This is a simplification that considers
|
|
/// cached instruction positions and ignores other basic blocks, being
|
|
/// only relevant to compare relative instructions positions inside \p BB.
|
|
bool OrderedBasicBlock::dominates(const Instruction *A, const Instruction *B) {
|
|
assert(A->getParent() == B->getParent() &&
|
|
"Instructions must be in the same basic block!");
|
|
assert(A->getParent() == BB && "Instructions must be in the tracked block!");
|
|
|
|
// First we lookup the instructions. If they don't exist, lookup will give us
|
|
// back ::end(). If they both exist, we compare the numbers. Otherwise, if NA
|
|
// exists and NB doesn't, it means NA must come before NB because we would
|
|
// have numbered NB as well if it didn't. The same is true for NB. If it
|
|
// exists, but NA does not, NA must come after it. If neither exist, we need
|
|
// to number the block and cache the results (by calling comesBefore).
|
|
auto NAI = NumberedInsts.find(A);
|
|
auto NBI = NumberedInsts.find(B);
|
|
if (NAI != NumberedInsts.end() && NBI != NumberedInsts.end())
|
|
return NAI->second < NBI->second;
|
|
if (NAI != NumberedInsts.end())
|
|
return true;
|
|
if (NBI != NumberedInsts.end())
|
|
return false;
|
|
|
|
return comesBefore(A, B);
|
|
}
|
|
|
|
void OrderedBasicBlock::eraseInstruction(const Instruction *I) {
|
|
if (LastInstFound != BB->end() && I == &*LastInstFound) {
|
|
if (LastInstFound == BB->begin()) {
|
|
LastInstFound = BB->end();
|
|
NextInstPos = 0;
|
|
} else
|
|
LastInstFound--;
|
|
}
|
|
|
|
NumberedInsts.erase(I);
|
|
}
|
|
|
|
void OrderedBasicBlock::replaceInstruction(const Instruction *Old,
|
|
const Instruction *New) {
|
|
auto OI = NumberedInsts.find(Old);
|
|
if (OI == NumberedInsts.end())
|
|
return;
|
|
|
|
NumberedInsts.insert({New, OI->second});
|
|
if (LastInstFound != BB->end() && Old == &*LastInstFound)
|
|
LastInstFound = New->getIterator();
|
|
NumberedInsts.erase(Old);
|
|
}
|