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