MachineModuleInfo.cpp revision 0220ba7995236accae6ac009a2700871fc17007d
1//===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9 10#include "llvm/CodeGen/MachineModuleInfo.h" 11 12#include "llvm/Constants.h" 13#include "llvm/DerivedTypes.h" 14#include "llvm/GlobalVariable.h" 15#include "llvm/Intrinsics.h" 16#include "llvm/Instructions.h" 17#include "llvm/Module.h" 18#include "llvm/Analysis/ValueTracking.h" 19#include "llvm/CodeGen/MachineFunctionPass.h" 20#include "llvm/CodeGen/MachineFunction.h" 21#include "llvm/CodeGen/Passes.h" 22#include "llvm/Target/TargetInstrInfo.h" 23#include "llvm/Target/TargetMachine.h" 24#include "llvm/Target/TargetOptions.h" 25#include "llvm/MC/MCSymbol.h" 26#include "llvm/Support/Dwarf.h" 27#include "llvm/Support/ErrorHandling.h" 28using namespace llvm; 29using namespace llvm::dwarf; 30 31// Handle the Pass registration stuff necessary to use TargetData's. 32static RegisterPass<MachineModuleInfo> 33X("machinemoduleinfo", "Machine Module Information"); 34char MachineModuleInfo::ID = 0; 35 36// Out of line virtual method. 37MachineModuleInfoImpl::~MachineModuleInfoImpl() {} 38 39namespace llvm { 40class MMIAddrLabelMapCallbackPtr : CallbackVH { 41 MMIAddrLabelMap *Map; 42public: 43 MMIAddrLabelMapCallbackPtr() : Map(0) {} 44 MMIAddrLabelMapCallbackPtr(Value *V) : CallbackVH(V), Map(0) {} 45 46 void setMap(MMIAddrLabelMap *map) { Map = map; } 47 48 virtual void deleted(); 49 virtual void allUsesReplacedWith(Value *V2); 50}; 51 52class MMIAddrLabelMap { 53 MCContext &Context; 54 struct AddrLabelSymEntry { 55 MCSymbol *Sym; 56 unsigned Index; 57 }; 58 59 DenseMap<AssertingVH<BasicBlock>, AddrLabelSymEntry> AddrLabelSymbols; 60 61 std::vector<MMIAddrLabelMapCallbackPtr> BBCallbacks; 62public: 63 64 MMIAddrLabelMap(MCContext &context) : Context(context) {} 65 66 MCSymbol *getAddrLabelSymbol(BasicBlock *BB); 67 void UpdateForDeletedBlock(BasicBlock *BB); 68 void UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New); 69}; 70} 71 72MCSymbol *MMIAddrLabelMap::getAddrLabelSymbol(BasicBlock *BB) { 73 assert(BB->hasAddressTaken() && 74 "Shouldn't get label for block without address taken"); 75 AddrLabelSymEntry &Entry = AddrLabelSymbols[BB]; 76 77 // If we already had an entry for this block, just return it. 78 if (Entry.Sym) return Entry.Sym; 79 80 // Otherwise, this is a new entry, create a new symbol for it and add an 81 // entry to BBCallbacks so we can be notified if the BB is deleted or RAUWd. 82 BBCallbacks.push_back(BB); 83 BBCallbacks.back().setMap(this); 84 Entry.Index = BBCallbacks.size()-1; 85 return Entry.Sym = Context.CreateTempSymbol(); 86} 87 88void MMIAddrLabelMap::UpdateForDeletedBlock(BasicBlock *BB) { 89 // If the block got deleted, there is no need for the symbol. If the symbol 90 // was already emitted, we can just forget about it, otherwise we need to 91 // queue it up for later emission when the function is output. 92 AddrLabelSymEntry Entry = AddrLabelSymbols[BB]; 93 AddrLabelSymbols.erase(BB); 94 assert(Entry.Sym && "Didn't have a symbol, why a callback?"); 95 BBCallbacks[Entry.Index] = 0; // Clear the callback. 96 97 if (Entry.Sym->isDefined()) 98 return; 99 100 // If the block is not yet defined, we need to emit it at the end of the 101 // function. 102 assert(0 && "Case not handled yet!"); 103 abort(); 104} 105 106void MMIAddrLabelMap::UpdateForRAUWBlock(BasicBlock *Old, BasicBlock *New) { 107 // Get the entry for the RAUW'd block and remove it from our map. 108 AddrLabelSymEntry OldEntry = AddrLabelSymbols[Old]; 109 AddrLabelSymbols.erase(Old); 110 assert(OldEntry.Sym && "Didn't have a symbol, why a callback?"); 111 112 // If New is not address taken, just move our symbol over to it. 113 if (!AddrLabelSymbols.count(New)) { 114 BBCallbacks[OldEntry.Index] = New; // Update the callback. 115 AddrLabelSymbols[New] = OldEntry; // Set New's entry. 116 } else { 117 assert(0 && "Case not handled yet!"); 118 abort(); 119 } 120} 121 122 123void MMIAddrLabelMapCallbackPtr::deleted() { 124 Map->UpdateForDeletedBlock(cast<BasicBlock>(getValPtr())); 125} 126 127void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value *V2) { 128 Map->UpdateForRAUWBlock(cast<BasicBlock>(getValPtr()), cast<BasicBlock>(V2)); 129} 130 131 132//===----------------------------------------------------------------------===// 133 134MachineModuleInfo::MachineModuleInfo(const MCAsmInfo &MAI) 135: ImmutablePass(&ID), Context(MAI), 136 ObjFileMMI(0), 137 CurCallSite(0), CallsEHReturn(0), CallsUnwindInit(0), DbgInfoAvailable(false){ 138 // Always emit some info, by default "no personality" info. 139 Personalities.push_back(NULL); 140 AddrLabelSymbols = 0; 141} 142 143MachineModuleInfo::MachineModuleInfo() 144: ImmutablePass(&ID), Context(*(MCAsmInfo*)0) { 145 assert(0 && "This MachineModuleInfo constructor should never be called, MMI " 146 "should always be explicitly constructed by LLVMTargetMachine"); 147 abort(); 148} 149 150MachineModuleInfo::~MachineModuleInfo() { 151 delete ObjFileMMI; 152 153 // FIXME: Why isn't doFinalization being called?? 154 //assert(AddrLabelSymbols == 0 && "doFinalization not called"); 155 delete AddrLabelSymbols; 156 AddrLabelSymbols = 0; 157} 158 159/// doInitialization - Initialize the state for a new module. 160/// 161bool MachineModuleInfo::doInitialization() { 162 assert(AddrLabelSymbols == 0 && "Improperly initialized"); 163 return false; 164} 165 166/// doFinalization - Tear down the state after completion of a module. 167/// 168bool MachineModuleInfo::doFinalization() { 169 delete AddrLabelSymbols; 170 AddrLabelSymbols = 0; 171 return false; 172} 173 174/// EndFunction - Discard function meta information. 175/// 176void MachineModuleInfo::EndFunction() { 177 // Clean up frame info. 178 FrameMoves.clear(); 179 180 // Clean up exception info. 181 LandingPads.clear(); 182 CallSiteMap.clear(); 183 TypeInfos.clear(); 184 FilterIds.clear(); 185 FilterEnds.clear(); 186 CallsEHReturn = 0; 187 CallsUnwindInit = 0; 188 VariableDbgInfo.clear(); 189} 190 191/// AnalyzeModule - Scan the module for global debug information. 192/// 193void MachineModuleInfo::AnalyzeModule(Module &M) { 194 // Insert functions in the llvm.used array (but not llvm.compiler.used) into 195 // UsedFunctions. 196 GlobalVariable *GV = M.getGlobalVariable("llvm.used"); 197 if (!GV || !GV->hasInitializer()) return; 198 199 // Should be an array of 'i8*'. 200 ConstantArray *InitList = dyn_cast<ConstantArray>(GV->getInitializer()); 201 if (InitList == 0) return; 202 203 for (unsigned i = 0, e = InitList->getNumOperands(); i != e; ++i) 204 if (Function *F = 205 dyn_cast<Function>(InitList->getOperand(i)->stripPointerCasts())) 206 UsedFunctions.insert(F); 207} 208 209//===- Address of Block Management ----------------------------------------===// 210 211 212/// getAddrLabelSymbol - Return the symbol to be used for the specified basic 213/// block when its address is taken. This cannot be its normal LBB label 214/// because the block may be accessed outside its containing function. 215MCSymbol *MachineModuleInfo::getAddrLabelSymbol(const BasicBlock *BB) { 216 // Lazily create AddrLabelSymbols. 217 if (AddrLabelSymbols == 0) 218 AddrLabelSymbols = new MMIAddrLabelMap(Context); 219 return AddrLabelSymbols->getAddrLabelSymbol(const_cast<BasicBlock*>(BB)); 220} 221 222 223//===- EH -----------------------------------------------------------------===// 224 225/// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the 226/// specified MachineBasicBlock. 227LandingPadInfo &MachineModuleInfo::getOrCreateLandingPadInfo 228 (MachineBasicBlock *LandingPad) { 229 unsigned N = LandingPads.size(); 230 for (unsigned i = 0; i < N; ++i) { 231 LandingPadInfo &LP = LandingPads[i]; 232 if (LP.LandingPadBlock == LandingPad) 233 return LP; 234 } 235 236 LandingPads.push_back(LandingPadInfo(LandingPad)); 237 return LandingPads[N]; 238} 239 240/// addInvoke - Provide the begin and end labels of an invoke style call and 241/// associate it with a try landing pad block. 242void MachineModuleInfo::addInvoke(MachineBasicBlock *LandingPad, 243 MCSymbol *BeginLabel, MCSymbol *EndLabel) { 244 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 245 LP.BeginLabels.push_back(BeginLabel); 246 LP.EndLabels.push_back(EndLabel); 247} 248 249/// addLandingPad - Provide the label of a try LandingPad block. 250/// 251MCSymbol *MachineModuleInfo::addLandingPad(MachineBasicBlock *LandingPad) { 252 MCSymbol *LandingPadLabel = Context.CreateTempSymbol(); 253 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 254 LP.LandingPadLabel = LandingPadLabel; 255 return LandingPadLabel; 256} 257 258/// addPersonality - Provide the personality function for the exception 259/// information. 260void MachineModuleInfo::addPersonality(MachineBasicBlock *LandingPad, 261 Function *Personality) { 262 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 263 LP.Personality = Personality; 264 265 for (unsigned i = 0; i < Personalities.size(); ++i) 266 if (Personalities[i] == Personality) 267 return; 268 269 // If this is the first personality we're adding go 270 // ahead and add it at the beginning. 271 if (Personalities[0] == NULL) 272 Personalities[0] = Personality; 273 else 274 Personalities.push_back(Personality); 275} 276 277/// addCatchTypeInfo - Provide the catch typeinfo for a landing pad. 278/// 279void MachineModuleInfo::addCatchTypeInfo(MachineBasicBlock *LandingPad, 280 std::vector<GlobalVariable *> &TyInfo) { 281 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 282 for (unsigned N = TyInfo.size(); N; --N) 283 LP.TypeIds.push_back(getTypeIDFor(TyInfo[N - 1])); 284} 285 286/// addFilterTypeInfo - Provide the filter typeinfo for a landing pad. 287/// 288void MachineModuleInfo::addFilterTypeInfo(MachineBasicBlock *LandingPad, 289 std::vector<GlobalVariable *> &TyInfo) { 290 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 291 std::vector<unsigned> IdsInFilter(TyInfo.size()); 292 for (unsigned I = 0, E = TyInfo.size(); I != E; ++I) 293 IdsInFilter[I] = getTypeIDFor(TyInfo[I]); 294 LP.TypeIds.push_back(getFilterIDFor(IdsInFilter)); 295} 296 297/// addCleanup - Add a cleanup action for a landing pad. 298/// 299void MachineModuleInfo::addCleanup(MachineBasicBlock *LandingPad) { 300 LandingPadInfo &LP = getOrCreateLandingPadInfo(LandingPad); 301 LP.TypeIds.push_back(0); 302} 303 304/// TidyLandingPads - Remap landing pad labels and remove any deleted landing 305/// pads. 306void MachineModuleInfo::TidyLandingPads() { 307 for (unsigned i = 0; i != LandingPads.size(); ) { 308 LandingPadInfo &LandingPad = LandingPads[i]; 309 if (LandingPad.LandingPadLabel && !LandingPad.LandingPadLabel->isDefined()) 310 LandingPad.LandingPadLabel = 0; 311 312 // Special case: we *should* emit LPs with null LP MBB. This indicates 313 // "nounwind" case. 314 if (!LandingPad.LandingPadLabel && LandingPad.LandingPadBlock) { 315 LandingPads.erase(LandingPads.begin() + i); 316 continue; 317 } 318 319 for (unsigned j = 0, e = LandingPads[i].BeginLabels.size(); j != e; ++j) { 320 MCSymbol *BeginLabel = LandingPad.BeginLabels[j]; 321 MCSymbol *EndLabel = LandingPad.EndLabels[j]; 322 if (BeginLabel->isDefined() && EndLabel->isDefined()) continue; 323 324 LandingPad.BeginLabels.erase(LandingPad.BeginLabels.begin() + j); 325 LandingPad.EndLabels.erase(LandingPad.EndLabels.begin() + j); 326 --j, --e; 327 } 328 329 // Remove landing pads with no try-ranges. 330 if (LandingPads[i].BeginLabels.empty()) { 331 LandingPads.erase(LandingPads.begin() + i); 332 continue; 333 } 334 335 // If there is no landing pad, ensure that the list of typeids is empty. 336 // If the only typeid is a cleanup, this is the same as having no typeids. 337 if (!LandingPad.LandingPadBlock || 338 (LandingPad.TypeIds.size() == 1 && !LandingPad.TypeIds[0])) 339 LandingPad.TypeIds.clear(); 340 ++i; 341 } 342} 343 344/// getTypeIDFor - Return the type id for the specified typeinfo. This is 345/// function wide. 346unsigned MachineModuleInfo::getTypeIDFor(GlobalVariable *TI) { 347 for (unsigned i = 0, N = TypeInfos.size(); i != N; ++i) 348 if (TypeInfos[i] == TI) return i + 1; 349 350 TypeInfos.push_back(TI); 351 return TypeInfos.size(); 352} 353 354/// getFilterIDFor - Return the filter id for the specified typeinfos. This is 355/// function wide. 356int MachineModuleInfo::getFilterIDFor(std::vector<unsigned> &TyIds) { 357 // If the new filter coincides with the tail of an existing filter, then 358 // re-use the existing filter. Folding filters more than this requires 359 // re-ordering filters and/or their elements - probably not worth it. 360 for (std::vector<unsigned>::iterator I = FilterEnds.begin(), 361 E = FilterEnds.end(); I != E; ++I) { 362 unsigned i = *I, j = TyIds.size(); 363 364 while (i && j) 365 if (FilterIds[--i] != TyIds[--j]) 366 goto try_next; 367 368 if (!j) 369 // The new filter coincides with range [i, end) of the existing filter. 370 return -(1 + i); 371 372try_next:; 373 } 374 375 // Add the new filter. 376 int FilterID = -(1 + FilterIds.size()); 377 FilterIds.reserve(FilterIds.size() + TyIds.size() + 1); 378 for (unsigned I = 0, N = TyIds.size(); I != N; ++I) 379 FilterIds.push_back(TyIds[I]); 380 FilterEnds.push_back(FilterIds.size()); 381 FilterIds.push_back(0); // terminator 382 return FilterID; 383} 384 385/// getPersonality - Return the personality function for the current function. 386Function *MachineModuleInfo::getPersonality() const { 387 // FIXME: Until PR1414 will be fixed, we're using 1 personality function per 388 // function 389 return !LandingPads.empty() ? LandingPads[0].Personality : NULL; 390} 391 392/// getPersonalityIndex - Return unique index for current personality 393/// function. NULL/first personality function should always get zero index. 394unsigned MachineModuleInfo::getPersonalityIndex() const { 395 const Function* Personality = NULL; 396 397 // Scan landing pads. If there is at least one non-NULL personality - use it. 398 for (unsigned i = 0; i != LandingPads.size(); ++i) 399 if (LandingPads[i].Personality) { 400 Personality = LandingPads[i].Personality; 401 break; 402 } 403 404 for (unsigned i = 0; i < Personalities.size(); ++i) { 405 if (Personalities[i] == Personality) 406 return i; 407 } 408 409 // This will happen if the current personality function is 410 // in the zero index. 411 return 0; 412} 413 414