1 //===- bolt/Passes/DataflowInfoManager.cpp --------------------------------===//
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 implements the DataflowInfoManager class.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #include "bolt/Passes/DataflowInfoManager.h"
14
15 namespace llvm {
16 namespace bolt {
17
getReachingDefs()18 ReachingDefOrUse</*Def=*/true> &DataflowInfoManager::getReachingDefs() {
19 if (RD)
20 return *RD;
21 assert(RA && "RegAnalysis required");
22 RD.reset(new ReachingDefOrUse<true>(*RA, BF, std::nullopt, AllocatorId));
23 RD->run();
24 return *RD;
25 }
26
invalidateReachingDefs()27 void DataflowInfoManager::invalidateReachingDefs() { RD.reset(nullptr); }
28
getReachingUses()29 ReachingDefOrUse</*Def=*/false> &DataflowInfoManager::getReachingUses() {
30 if (RU)
31 return *RU;
32 assert(RA && "RegAnalysis required");
33 RU.reset(new ReachingDefOrUse<false>(*RA, BF, std::nullopt, AllocatorId));
34 RU->run();
35 return *RU;
36 }
37
invalidateReachingUses()38 void DataflowInfoManager::invalidateReachingUses() { RU.reset(nullptr); }
39
getLivenessAnalysis()40 LivenessAnalysis &DataflowInfoManager::getLivenessAnalysis() {
41 if (LA)
42 return *LA;
43 assert(RA && "RegAnalysis required");
44 LA.reset(new LivenessAnalysis(*RA, BF, AllocatorId));
45 LA->run();
46 return *LA;
47 }
48
invalidateLivenessAnalysis()49 void DataflowInfoManager::invalidateLivenessAnalysis() { LA.reset(nullptr); }
50
getStackReachingUses()51 StackReachingUses &DataflowInfoManager::getStackReachingUses() {
52 if (SRU)
53 return *SRU;
54 assert(FA && "FrameAnalysis required");
55 SRU.reset(new StackReachingUses(*FA, BF, AllocatorId));
56 SRU->run();
57 return *SRU;
58 }
59
invalidateStackReachingUses()60 void DataflowInfoManager::invalidateStackReachingUses() { SRU.reset(nullptr); }
61
getDominatorAnalysis()62 DominatorAnalysis<false> &DataflowInfoManager::getDominatorAnalysis() {
63 if (DA)
64 return *DA;
65 DA.reset(new DominatorAnalysis<false>(BF, AllocatorId));
66 DA->run();
67 return *DA;
68 }
69
invalidateDominatorAnalysis()70 void DataflowInfoManager::invalidateDominatorAnalysis() { DA.reset(nullptr); }
71
getPostDominatorAnalysis()72 DominatorAnalysis<true> &DataflowInfoManager::getPostDominatorAnalysis() {
73 if (PDA)
74 return *PDA;
75 PDA.reset(new DominatorAnalysis<true>(BF, AllocatorId));
76 PDA->run();
77 return *PDA;
78 }
79
invalidatePostDominatorAnalysis()80 void DataflowInfoManager::invalidatePostDominatorAnalysis() {
81 PDA.reset(nullptr);
82 }
83
getStackPointerTracking()84 StackPointerTracking &DataflowInfoManager::getStackPointerTracking() {
85 if (SPT)
86 return *SPT;
87 SPT.reset(new StackPointerTracking(BF, AllocatorId));
88 SPT->run();
89 return *SPT;
90 }
91
invalidateStackPointerTracking()92 void DataflowInfoManager::invalidateStackPointerTracking() {
93 invalidateStackAllocationAnalysis();
94 SPT.reset(nullptr);
95 }
96
getReachingInsns()97 ReachingInsns<false> &DataflowInfoManager::getReachingInsns() {
98 if (RI)
99 return *RI;
100 RI.reset(new ReachingInsns<false>(BF, AllocatorId));
101 RI->run();
102 return *RI;
103 }
104
invalidateReachingInsns()105 void DataflowInfoManager::invalidateReachingInsns() { RI.reset(nullptr); }
106
getReachingInsnsBackwards()107 ReachingInsns<true> &DataflowInfoManager::getReachingInsnsBackwards() {
108 if (RIB)
109 return *RIB;
110 RIB.reset(new ReachingInsns<true>(BF, AllocatorId));
111 RIB->run();
112 return *RIB;
113 }
114
invalidateReachingInsnsBackwards()115 void DataflowInfoManager::invalidateReachingInsnsBackwards() {
116 RIB.reset(nullptr);
117 }
118
getStackAllocationAnalysis()119 StackAllocationAnalysis &DataflowInfoManager::getStackAllocationAnalysis() {
120 if (SAA)
121 return *SAA;
122 SAA.reset(
123 new StackAllocationAnalysis(BF, getStackPointerTracking(), AllocatorId));
124 SAA->run();
125 return *SAA;
126 }
127
invalidateStackAllocationAnalysis()128 void DataflowInfoManager::invalidateStackAllocationAnalysis() {
129 SAA.reset(nullptr);
130 }
131
132 std::unordered_map<const MCInst *, BinaryBasicBlock *> &
getInsnToBBMap()133 DataflowInfoManager::getInsnToBBMap() {
134 if (InsnToBB)
135 return *InsnToBB;
136 InsnToBB.reset(new std::unordered_map<const MCInst *, BinaryBasicBlock *>());
137 for (BinaryBasicBlock &BB : BF) {
138 for (MCInst &Inst : BB)
139 (*InsnToBB)[&Inst] = &BB;
140 }
141 return *InsnToBB;
142 }
143
invalidateInsnToBBMap()144 void DataflowInfoManager::invalidateInsnToBBMap() { InsnToBB.reset(nullptr); }
145
invalidateAll()146 void DataflowInfoManager::invalidateAll() {
147 invalidateReachingDefs();
148 invalidateReachingUses();
149 invalidateLivenessAnalysis();
150 invalidateStackReachingUses();
151 invalidateDominatorAnalysis();
152 invalidatePostDominatorAnalysis();
153 invalidateStackPointerTracking();
154 invalidateReachingInsns();
155 invalidateReachingInsnsBackwards();
156 invalidateStackAllocationAnalysis();
157 invalidateInsnToBBMap();
158 }
159
160 } // end namespace bolt
161 } // end namespace llvm
162