Coverage Report

Created: 2019-02-21 13:17

/Users/buildslave/jenkins/workspace/clang-stage2-coverage-R/llvm/include/llvm/CodeGen/MachineLoopInfo.h
Line
Count
Source (jump to first uncovered line)
1
//===- llvm/CodeGen/MachineLoopInfo.h - Natural Loop Calculator -*- 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 file defines the MachineLoopInfo class that is used to identify natural
10
// loops and determine the loop depth of various nodes of the CFG.  Note that
11
// natural loops may actually be several loops that share the same header node.
12
//
13
// This analysis calculates the nesting structure of loops in a function.  For
14
// each natural loop identified, this analysis identifies natural loops
15
// contained entirely within the loop and the basic blocks the make up the loop.
16
//
17
// It can calculate on the fly various bits of information, for example:
18
//
19
//  * whether there is a preheader for the loop
20
//  * the number of back edges to the header
21
//  * whether or not a particular block branches out of the loop
22
//  * the successor blocks of the loop
23
//  * the loop depth
24
//  * the trip count
25
//  * etc...
26
//
27
//===----------------------------------------------------------------------===//
28
29
#ifndef LLVM_CODEGEN_MACHINELOOPINFO_H
30
#define LLVM_CODEGEN_MACHINELOOPINFO_H
31
32
#include "llvm/Analysis/LoopInfo.h"
33
#include "llvm/CodeGen/MachineBasicBlock.h"
34
#include "llvm/CodeGen/MachineFunctionPass.h"
35
#include "llvm/IR/DebugLoc.h"
36
#include "llvm/Pass.h"
37
38
namespace llvm {
39
40
// Implementation in LoopInfoImpl.h
41
class MachineLoop;
42
extern template class LoopBase<MachineBasicBlock, MachineLoop>;
43
44
class MachineLoop : public LoopBase<MachineBasicBlock, MachineLoop> {
45
public:
46
  /// Return the "top" block in the loop, which is the first block in the linear
47
  /// layout, ignoring any parts of the loop not contiguous with the part that
48
  /// contains the header.
49
  MachineBasicBlock *getTopBlock();
50
51
  /// Return the "bottom" block in the loop, which is the last block in the
52
  /// linear layout, ignoring any parts of the loop not contiguous with the part
53
  /// that contains the header.
54
  MachineBasicBlock *getBottomBlock();
55
56
  /// Find the block that contains the loop control variable and the
57
  /// loop test. This will return the latch block if it's one of the exiting
58
  /// blocks. Otherwise, return the exiting block. Return 'null' when
59
  /// multiple exiting blocks are present.
60
  MachineBasicBlock *findLoopControlBlock();
61
62
  /// Return the debug location of the start of this loop.
63
  /// This looks for a BB terminating instruction with a known debug
64
  /// location by looking at the preheader and header blocks. If it
65
  /// cannot find a terminating instruction with location information,
66
  /// it returns an unknown location.
67
  DebugLoc getStartLoc() const;
68
69
  void dump() const;
70
71
private:
72
  friend class LoopInfoBase<MachineBasicBlock, MachineLoop>;
73
74
  explicit MachineLoop(MachineBasicBlock *MBB)
75
849k
    : LoopBase<MachineBasicBlock, MachineLoop>(MBB) {}
76
77
  MachineLoop() = default;
78
};
79
80
// Implementation in LoopInfoImpl.h
81
extern template class LoopInfoBase<MachineBasicBlock, MachineLoop>;
82
83
class MachineLoopInfo : public MachineFunctionPass {
84
  friend class LoopBase<MachineBasicBlock, MachineLoop>;
85
86
  LoopInfoBase<MachineBasicBlock, MachineLoop> LI;
87
88
public:
89
  static char ID; // Pass identification, replacement for typeid
90
91
348k
  MachineLoopInfo() : MachineFunctionPass(ID) {
92
348k
    initializeMachineLoopInfoPass(*PassRegistry::getPassRegistry());
93
348k
  }
94
  MachineLoopInfo(const MachineLoopInfo &) = delete;
95
  MachineLoopInfo &operator=(const MachineLoopInfo &) = delete;
96
97
238k
  LoopInfoBase<MachineBasicBlock, MachineLoop>& getBase() { return LI; }
98
99
  /// Find the block that either is the loop preheader, or could
100
  /// speculatively be used as the preheader. This is e.g. useful to place
101
  /// loop setup code. Code that cannot be speculated should not be placed
102
  /// here. SpeculativePreheader is controlling whether it also tries to
103
  /// find the speculative preheader if the regular preheader is not present.
104
  MachineBasicBlock *findLoopPreheader(MachineLoop *L,
105
                                       bool SpeculativePreheader = false) const;
106
107
  /// The iterator interface to the top-level loops in the current function.
108
  using iterator = LoopInfoBase<MachineBasicBlock, MachineLoop>::iterator;
109
1.98M
  inline iterator begin() const { return LI.begin(); }
110
1.98M
  inline iterator end() const { return LI.end(); }
111
1.91M
  bool empty() const { return LI.empty(); }
112
113
  /// Return the innermost loop that BB lives in. If a basic block is in no loop
114
  /// (for example the entry node), null is returned.
115
37.7M
  inline MachineLoop *getLoopFor(const MachineBasicBlock *BB) const {
116
37.7M
    return LI.getLoopFor(BB);
117
37.7M
  }
118
119
  /// Same as getLoopFor.
120
0
  inline const MachineLoop *operator[](const MachineBasicBlock *BB) const {
121
0
    return LI.getLoopFor(BB);
122
0
  }
123
124
  /// Return the loop nesting level of the specified block.
125
5.31M
  inline unsigned getLoopDepth(const MachineBasicBlock *BB) const {
126
5.31M
    return LI.getLoopDepth(BB);
127
5.31M
  }
128
129
  /// True if the block is a loop header node.
130
3.51M
  inline bool isLoopHeader(const MachineBasicBlock *BB) const {
131
3.51M
    return LI.isLoopHeader(BB);
132
3.51M
  }
133
134
  /// Calculate the natural loop information.
135
  bool runOnMachineFunction(MachineFunction &F) override;
136
137
3.99M
  void releaseMemory() override { LI.releaseMemory(); }
138
139
  void getAnalysisUsage(AnalysisUsage &AU) const override;
140
141
  /// This removes the specified top-level loop from this loop info object. The
142
  /// loop is not deleted, as it will presumably be inserted into another loop.
143
0
  inline MachineLoop *removeLoop(iterator I) { return LI.removeLoop(I); }
144
145
  /// Change the top-level loop that contains BB to the specified loop. This
146
  /// should be used by transformations that restructure the loop hierarchy
147
  /// tree.
148
27
  inline void changeLoopFor(MachineBasicBlock *BB, MachineLoop *L) {
149
27
    LI.changeLoopFor(BB, L);
150
27
  }
151
152
  /// Replace the specified loop in the top-level loops list with the indicated
153
  /// loop.
154
0
  inline void changeTopLevelLoop(MachineLoop *OldLoop, MachineLoop *NewLoop) {
155
0
    LI.changeTopLevelLoop(OldLoop, NewLoop);
156
0
  }
157
158
  /// This adds the specified loop to the collection of top-level loops.
159
0
  inline void addTopLevelLoop(MachineLoop *New) {
160
0
    LI.addTopLevelLoop(New);
161
0
  }
162
163
  /// This method completely removes BB from all data structures, including all
164
  /// of the Loop objects it is nested in and our mapping from
165
  /// MachineBasicBlocks to loops.
166
70.0k
  void removeBlock(MachineBasicBlock *BB) {
167
70.0k
    LI.removeBlock(BB);
168
70.0k
  }
169
};
170
171
// Allow clients to walk the list of nested loops...
172
template <> struct GraphTraits<const MachineLoop*> {
173
  using NodeRef = const MachineLoop *;
174
  using ChildIteratorType = MachineLoopInfo::iterator;
175
176
  static NodeRef getEntryNode(const MachineLoop *L) { return L; }
177
  static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
178
  static ChildIteratorType child_end(NodeRef N) { return N->end(); }
179
};
180
181
template <> struct GraphTraits<MachineLoop*> {
182
  using NodeRef = MachineLoop *;
183
  using ChildIteratorType = MachineLoopInfo::iterator;
184
185
123
  static NodeRef getEntryNode(MachineLoop *L) { return L; }
186
135
  static ChildIteratorType child_begin(NodeRef N) { return N->begin(); }
187
147
  static ChildIteratorType child_end(NodeRef N) { return N->end(); }
188
};
189
190
} // end namespace llvm
191
192
#endif // LLVM_CODEGEN_MACHINELOOPINFO_H