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