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. Trace(const std::vector<BasicBlock * > & vBB)39 Trace(const std::vector<BasicBlock *> &vBB) : BasicBlocks (vBB) {} 40 41 /// getEntryBasicBlock - Return the entry basic block (first block) 42 /// of the trace. getEntryBasicBlock()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]; } getBlock(unsigned 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. getBlockIndex(const BasicBlock * X)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. contains(const BasicBlock * X)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. dominates(const BasicBlock * B1,const BasicBlock * B2)73 bool dominates(const BasicBlock *B1, const BasicBlock *B2) const { 74 int B1Idx = getBlockIndex(B1), B2Idx = getBlockIndex(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 begin()85 iterator begin() { return BasicBlocks.begin(); } begin()86 const_iterator begin() const { return BasicBlocks.begin(); } end()87 iterator end () { return BasicBlocks.end(); } end()88 const_iterator end () const { return BasicBlocks.end(); } 89 rbegin()90 reverse_iterator rbegin() { return BasicBlocks.rbegin(); } rbegin()91 const_reverse_iterator rbegin() const { return BasicBlocks.rbegin(); } rend()92 reverse_iterator rend () { return BasicBlocks.rend(); } rend()93 const_reverse_iterator rend () const { return BasicBlocks.rend(); } 94 size()95 unsigned size() const { return BasicBlocks.size(); } empty()96 bool empty() const { return BasicBlocks.empty(); } 97 erase(iterator q)98 iterator erase(iterator q) { return BasicBlocks.erase (q); } erase(iterator q1,iterator q2)99 iterator erase(iterator q1, iterator q2) { return BasicBlocks.erase (q1, 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