12 #include "llvm/Support/Casting.h" 16 using namespace clang;
17 using namespace threadSafety;
52 SExpr* Future::force() {
60 unsigned Idx = Predecessors.size();
61 Predecessors.reserveCheck(1, Arena);
62 Predecessors.push_back(Pred);
63 for (
auto *E : Args) {
64 if (
auto *Ph = dyn_cast<Phi>(E)) {
65 Ph->values().reserveCheck(1, Arena);
66 Ph->values().push_back(
nullptr);
73 Predecessors.reserve(NumPreds, Arena);
74 for (
auto *E : Args) {
75 if (
auto *Ph = dyn_cast<Phi>(E)) {
76 Ph->values().reserve(NumPreds, Arena);
85 if (
const auto *V = dyn_cast<Variable>(E)) {
91 if (
const auto *Ph = dyn_cast<Phi>(E)) {
107 if (
auto *V = dyn_cast<Variable>(E)) {
118 if (
auto *Ph = dyn_cast<Phi>(E)) {
141 for (
unsigned i = 1, n = Ph->
values().
size(); i < n; ++i) {
153 int BasicBlock::renumberInstrs(
int ID) {
154 for (
auto *Arg : Args)
155 Arg->setID(
this, ID++);
156 for (
auto *Instr : Instrs)
157 Instr->setID(
this, ID++);
158 TermInstr->setID(
this, ID++);
167 if (Visited)
return ID;
169 for (
auto *
Block : successors())
170 ID =
Block->topologicalSort(Blocks, ID);
175 Blocks[BlockID] =
this;
192 if (!Visited)
return ID;
194 if (DominatorNode.Parent)
195 ID = DominatorNode.Parent->topologicalFinalSort(Blocks, ID);
196 for (
auto *Pred : Predecessors)
197 ID = Pred->topologicalFinalSort(Blocks, ID);
198 assert(static_cast<size_t>(ID) < Blocks.
size());
200 Blocks[BlockID] =
this;
207 void BasicBlock::computeDominator() {
210 for (
auto *Pred : Predecessors) {
212 if (Pred->BlockID >= BlockID)
continue;
214 if (Candidate ==
nullptr) {
219 auto *Alternate = Pred;
220 while (Alternate != Candidate) {
221 if (Candidate->BlockID > Alternate->BlockID)
222 Candidate = Candidate->DominatorNode.
Parent;
224 Alternate = Alternate->DominatorNode.
Parent;
227 DominatorNode.Parent = Candidate;
228 DominatorNode.SizeOfSubTree = 1;
234 void BasicBlock::computePostDominator() {
237 for (
auto *Succ : successors()) {
239 if (Succ->BlockID <= BlockID)
continue;
241 if (Candidate ==
nullptr) {
246 auto *Alternate = Succ;
247 while (Alternate != Candidate) {
248 if (Candidate->BlockID < Alternate->BlockID)
249 Candidate = Candidate->PostDominatorNode.
Parent;
251 Alternate = Alternate->PostDominatorNode.
Parent;
254 PostDominatorNode.Parent = Candidate;
255 PostDominatorNode.SizeOfSubTree = 1;
259 void SCFG::renumberInstrs() {
261 for (
auto *
Block : Blocks)
262 InstrID =
Block->renumberInstrs(InstrID);
291 int NumUnreachableBlocks = Entry->topologicalSort(Blocks, Blocks.
size());
292 if (NumUnreachableBlocks > 0) {
294 for (
size_t I = NumUnreachableBlocks, E = Blocks.
size(); I < E; ++I) {
295 size_t NI = I - NumUnreachableBlocks;
296 Blocks[NI] = Blocks[I];
297 Blocks[NI]->BlockID = NI;
300 Blocks.
drop(NumUnreachableBlocks);
304 for (
auto *
Block : Blocks)
305 Block->computeDominator();
308 int NumBlocks = Exit->topologicalFinalSort(Blocks, 0);
309 assert(static_cast<size_t>(NumBlocks) == Blocks.size());
317 for (
auto *
Block : Blocks.reverse()) {
318 Block->computePostDominator();
323 for (
auto *
Block : Blocks) {
328 for (
auto *
Block : Blocks.reverse()) {
StringRef getBinaryOpcodeString(TIL_BinaryOpcode Op)
Return the name of a binary opcode.
SExpr * simplifyToCanonicalVal(SExpr *E)
unsigned addPredecessor(BasicBlock *Pred)
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
virtual SExpr * compute()
A basic block is part of an SCFG.
static void computeNodeSize(BasicBlock *B, BasicBlock::TopologyNode BasicBlock::*TN)
StringRef getUnaryOpcodeString(TIL_UnaryOpcode Op)
Return the name of a unary opcode.
TIL_BinaryOpcode
Opcode for binary arithmetic operations.
void reservePredecessors(unsigned NumPreds)
const ValArray & values() const
TIL_UnaryOpcode
Opcode for unary arithmetic operations.
const SExpr * getCanonicalVal(const SExpr *E)
Dataflow Directional Tag Classes.
Phi Node, for code in SSA form.
static void computeNodeID(BasicBlock *B, BasicBlock::TopologyNode BasicBlock::*TN)
bool isTrivial(const SExpr *E)
void simplifyIncompleteArg(til::Phi *Ph)
Base class for AST nodes in the typed intermediate language.