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 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, None, AllocatorId)); 23 RD->run(); 24 return *RD; 25 } 26 27 void DataflowInfoManager::invalidateReachingDefs() { RD.reset(nullptr); } 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, BF, None, AllocatorId)); 34 RU->run(); 35 return *RU; 36 } 37 38 void DataflowInfoManager::invalidateReachingUses() { RU.reset(nullptr); } 39 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 49 void DataflowInfoManager::invalidateLivenessAnalysis() { LA.reset(nullptr); } 50 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 60 void DataflowInfoManager::invalidateStackReachingUses() { SRU.reset(nullptr); } 61 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 70 void DataflowInfoManager::invalidateDominatorAnalysis() { DA.reset(nullptr); } 71 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 80 void DataflowInfoManager::invalidatePostDominatorAnalysis() { 81 PDA.reset(nullptr); 82 } 83 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 92 void DataflowInfoManager::invalidateStackPointerTracking() { 93 invalidateStackAllocationAnalysis(); 94 SPT.reset(nullptr); 95 } 96 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 105 void DataflowInfoManager::invalidateReachingInsns() { RI.reset(nullptr); } 106 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 115 void DataflowInfoManager::invalidateReachingInsnsBackwards() { 116 RIB.reset(nullptr); 117 } 118 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 128 void DataflowInfoManager::invalidateStackAllocationAnalysis() { 129 SAA.reset(nullptr); 130 } 131 132 std::unordered_map<const MCInst *, BinaryBasicBlock *> & 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 144 void DataflowInfoManager::invalidateInsnToBBMap() { InsnToBB.reset(nullptr); } 145 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