1 | //===- llvm/Analysis/Trace.h - Represent one trace of LLVM code -*- C++ -*-===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This class represents a single trace of LLVM basic blocks. A trace is a |
10 | // single entry, multiple exit, region of code that is often hot. Trace-based |
11 | // optimizations treat traces almost like they are a large, strange, basic |
12 | // block: because the trace path is assumed to be hot, optimizations for the |
13 | // fall-through path are made at the expense of the non-fall-through paths. |
14 | // |
15 | //===----------------------------------------------------------------------===// |
16 | |
17 | #ifndef LLVM_ANALYSIS_TRACE_H |
18 | #define LLVM_ANALYSIS_TRACE_H |
19 | |
20 | #include <cassert> |
21 | #include <vector> |
22 | |
23 | namespace llvm { |
24 | |
25 | class BasicBlock; |
26 | class Function; |
27 | class Module; |
28 | class raw_ostream; |
29 | |
30 | class Trace { |
31 | using BasicBlockListType = std::vector<BasicBlock *>; |
32 | |
33 | BasicBlockListType BasicBlocks; |
34 | |
35 | public: |
36 | /// Trace ctor - Make a new trace from a vector of basic blocks, |
37 | /// residing in the function which is the parent of the first |
38 | /// basic block in the vector. |
39 | Trace(const std::vector<BasicBlock *> &vBB) : BasicBlocks (vBB) {} |
40 | |
41 | /// getEntryBasicBlock - Return the entry basic block (first block) |
42 | /// of the trace. |
43 | BasicBlock *getEntryBasicBlock () const { return BasicBlocks[0]; } |
44 | |
45 | /// operator[]/getBlock - Return basic block N in the trace. |
46 | BasicBlock *operator[](unsigned i) const { return BasicBlocks[i]; } |
47 | BasicBlock *getBlock(unsigned i) const { return BasicBlocks[i]; } |
48 | |
49 | /// getFunction - Return this trace's parent function. |
50 | Function *getFunction () const; |
51 | |
52 | /// getModule - Return this Module that contains this trace's parent |
53 | /// function. |
54 | Module *getModule () const; |
55 | |
56 | /// getBlockIndex - Return the index of the specified basic block in the |
57 | /// trace, or -1 if it is not in the trace. |
58 | int getBlockIndex(const BasicBlock *X) const { |
59 | for (unsigned i = 0, e = BasicBlocks.size(); i != e; ++i) |
60 | if (BasicBlocks[i] == X) |
61 | return i; |
62 | return -1; |
63 | } |
64 | |
65 | /// contains - Returns true if this trace contains the given basic |
66 | /// block. |
67 | bool contains(const BasicBlock *X) const { |
68 | return getBlockIndex(X) != -1; |
69 | } |
70 | |
71 | /// Returns true if B1 occurs before B2 in the trace, or if it is the same |
72 | /// block as B2.. Both blocks must be in the trace. |
73 | bool dominates(const BasicBlock *B1, const BasicBlock *B2) const { |
74 | int B1Idx = getBlockIndex(X: B1), B2Idx = getBlockIndex(X: B2); |
75 | assert(B1Idx != -1 && B2Idx != -1 && "Block is not in the trace!" ); |
76 | return B1Idx <= B2Idx; |
77 | } |
78 | |
79 | // BasicBlock iterators... |
80 | using iterator = BasicBlockListType::iterator; |
81 | using const_iterator = BasicBlockListType::const_iterator; |
82 | using reverse_iterator = std::reverse_iterator<iterator>; |
83 | using const_reverse_iterator = std::reverse_iterator<const_iterator>; |
84 | |
85 | iterator begin() { return BasicBlocks.begin(); } |
86 | const_iterator begin() const { return BasicBlocks.begin(); } |
87 | iterator end () { return BasicBlocks.end(); } |
88 | const_iterator end () const { return BasicBlocks.end(); } |
89 | |
90 | reverse_iterator rbegin() { return BasicBlocks.rbegin(); } |
91 | const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); } |
92 | reverse_iterator rend () { return BasicBlocks.rend(); } |
93 | const_reverse_iterator rend () const { return BasicBlocks.rend(); } |
94 | |
95 | unsigned size() const { return BasicBlocks.size(); } |
96 | bool empty() const { return BasicBlocks.empty(); } |
97 | |
98 | iterator erase(iterator q) { return BasicBlocks.erase (position: q); } |
99 | iterator erase(iterator q1, iterator q2) { return BasicBlocks.erase (first: q1, last: q2); } |
100 | |
101 | /// print - Write trace to output stream. |
102 | void print(raw_ostream &O) const; |
103 | |
104 | /// dump - Debugger convenience method; writes trace to standard error |
105 | /// output stream. |
106 | void dump() const; |
107 | }; |
108 | |
109 | } // end namespace llvm |
110 | |
111 | #endif // LLVM_ANALYSIS_TRACE_H |
112 | |