1 //===-- llvm/CodeGen/MachineModuleInfo.cpp ----------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "llvm/CodeGen/MachineModuleInfo.h"
11 #include "llvm/ADT/PointerUnion.h"
12 #include "llvm/Analysis/ValueTracking.h"
13 #include "llvm/CodeGen/MachineFunction.h"
14 #include "llvm/CodeGen/MachineFunctionPass.h"
15 #include "llvm/CodeGen/Passes.h"
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DerivedTypes.h"
18 #include "llvm/IR/GlobalVariable.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/MC/MCObjectFileInfo.h"
21 #include "llvm/MC/MCSymbol.h"
22 #include "llvm/Support/Dwarf.h"
23 #include "llvm/Support/ErrorHandling.h"
25 using namespace llvm::dwarf
;
27 // Handle the Pass registration stuff necessary to use DataLayout's.
28 INITIALIZE_PASS(MachineModuleInfo
, "machinemoduleinfo",
29 "Machine Module Information", false, false)
30 char MachineModuleInfo::ID
= 0;
32 // Out of line virtual method.
33 MachineModuleInfoImpl::~MachineModuleInfoImpl() {}
36 class MMIAddrLabelMapCallbackPtr
: CallbackVH
{
39 MMIAddrLabelMapCallbackPtr() : Map(nullptr) {}
40 MMIAddrLabelMapCallbackPtr(Value
*V
) : CallbackVH(V
), Map(nullptr) {}
42 void setPtr(BasicBlock
*BB
) {
43 ValueHandleBase::operator=(BB
);
46 void setMap(MMIAddrLabelMap
*map
) { Map
= map
; }
48 void deleted() override
;
49 void allUsesReplacedWith(Value
*V2
) override
;
52 class MMIAddrLabelMap
{
54 struct AddrLabelSymEntry
{
55 /// Symbols - The symbols for the label. This is a pointer union that is
56 /// either one symbol (the common case) or a list of symbols.
57 PointerUnion
<MCSymbol
*, std::vector
<MCSymbol
*>*> Symbols
;
59 Function
*Fn
; // The containing function of the BasicBlock.
60 unsigned Index
; // The index in BBCallbacks for the BasicBlock.
63 DenseMap
<AssertingVH
<BasicBlock
>, AddrLabelSymEntry
> AddrLabelSymbols
;
65 /// BBCallbacks - Callbacks for the BasicBlock's that we have entries for. We
66 /// use this so we get notified if a block is deleted or RAUWd.
67 std::vector
<MMIAddrLabelMapCallbackPtr
> BBCallbacks
;
69 /// DeletedAddrLabelsNeedingEmission - This is a per-function list of symbols
70 /// whose corresponding BasicBlock got deleted. These symbols need to be
71 /// emitted at some point in the file, so AsmPrinter emits them after the
73 DenseMap
<AssertingVH
<Function
>, std::vector
<MCSymbol
*> >
74 DeletedAddrLabelsNeedingEmission
;
77 MMIAddrLabelMap(MCContext
&context
) : Context(context
) {}
79 assert(DeletedAddrLabelsNeedingEmission
.empty() &&
80 "Some labels for deleted blocks never got emitted");
82 // Deallocate any of the 'list of symbols' case.
83 for (DenseMap
<AssertingVH
<BasicBlock
>, AddrLabelSymEntry
>::iterator
84 I
= AddrLabelSymbols
.begin(), E
= AddrLabelSymbols
.end(); I
!= E
; ++I
)
85 if (I
->second
.Symbols
.is
<std::vector
<MCSymbol
*>*>())
86 delete I
->second
.Symbols
.get
<std::vector
<MCSymbol
*>*>();
89 MCSymbol
*getAddrLabelSymbol(BasicBlock
*BB
);
90 std::vector
<MCSymbol
*> getAddrLabelSymbolToEmit(BasicBlock
*BB
);
92 void takeDeletedSymbolsForFunction(Function
*F
,
93 std::vector
<MCSymbol
*> &Result
);
95 void UpdateForDeletedBlock(BasicBlock
*BB
);
96 void UpdateForRAUWBlock(BasicBlock
*Old
, BasicBlock
*New
);
100 MCSymbol
*MMIAddrLabelMap::getAddrLabelSymbol(BasicBlock
*BB
) {
101 assert(BB
->hasAddressTaken() &&
102 "Shouldn't get label for block without address taken");
103 AddrLabelSymEntry
&Entry
= AddrLabelSymbols
[BB
];
105 // If we already had an entry for this block, just return it.
106 if (!Entry
.Symbols
.isNull()) {
107 assert(BB
->getParent() == Entry
.Fn
&& "Parent changed");
108 if (Entry
.Symbols
.is
<MCSymbol
*>())
109 return Entry
.Symbols
.get
<MCSymbol
*>();
110 return (*Entry
.Symbols
.get
<std::vector
<MCSymbol
*>*>())[0];
113 // Otherwise, this is a new entry, create a new symbol for it and add an
114 // entry to BBCallbacks so we can be notified if the BB is deleted or RAUWd.
115 BBCallbacks
.push_back(BB
);
116 BBCallbacks
.back().setMap(this);
117 Entry
.Index
= BBCallbacks
.size()-1;
118 Entry
.Fn
= BB
->getParent();
119 MCSymbol
*Result
= Context
.CreateTempSymbol();
120 Entry
.Symbols
= Result
;
124 std::vector
<MCSymbol
*>
125 MMIAddrLabelMap::getAddrLabelSymbolToEmit(BasicBlock
*BB
) {
126 assert(BB
->hasAddressTaken() &&
127 "Shouldn't get label for block without address taken");
128 AddrLabelSymEntry
&Entry
= AddrLabelSymbols
[BB
];
130 std::vector
<MCSymbol
*> Result
;
132 // If we already had an entry for this block, just return it.
133 if (Entry
.Symbols
.isNull())
134 Result
.push_back(getAddrLabelSymbol(BB
));
135 else if (MCSymbol
*Sym
= Entry
.Symbols
.dyn_cast
<MCSymbol
*>())
136 Result
.push_back(Sym
);
138 Result
= *Entry
.Symbols
.get
<std::vector
<MCSymbol
*>*>();
143 /// takeDeletedSymbolsForFunction - If we have any deleted symbols for F, return
145 void MMIAddrLabelMap::
146 takeDeletedSymbolsForFunction(Function
*F
, std::vector
<MCSymbol
*> &Result
) {
147 DenseMap
<AssertingVH
<Function
>, std::vector
<MCSymbol
*> >::iterator I
=
148 DeletedAddrLabelsNeedingEmission
.find(F
);
150 // If there are no entries for the function, just return.
151 if (I
== DeletedAddrLabelsNeedingEmission
.end()) return;
153 // Otherwise, take the list.
154 std::swap(Result
, I
->second
);
155 DeletedAddrLabelsNeedingEmission
.erase(I
);
159 void MMIAddrLabelMap::UpdateForDeletedBlock(BasicBlock
*BB
) {
160 // If the block got deleted, there is no need for the symbol. If the symbol
161 // was already emitted, we can just forget about it, otherwise we need to
162 // queue it up for later emission when the function is output.
163 AddrLabelSymEntry Entry
= AddrLabelSymbols
[BB
];
164 AddrLabelSymbols
.erase(BB
);
165 assert(!Entry
.Symbols
.isNull() && "Didn't have a symbol, why a callback?");
166 BBCallbacks
[Entry
.Index
] = nullptr; // Clear the callback.
168 assert((BB
->getParent() == nullptr || BB
->getParent() == Entry
.Fn
) &&
169 "Block/parent mismatch");
171 // Handle both the single and the multiple symbols cases.
172 if (MCSymbol
*Sym
= Entry
.Symbols
.dyn_cast
<MCSymbol
*>()) {
173 if (Sym
->isDefined())
176 // If the block is not yet defined, we need to emit it at the end of the
177 // function. Add the symbol to the DeletedAddrLabelsNeedingEmission list
178 // for the containing Function. Since the block is being deleted, its
179 // parent may already be removed, we have to get the function from 'Entry'.
180 DeletedAddrLabelsNeedingEmission
[Entry
.Fn
].push_back(Sym
);
182 std::vector
<MCSymbol
*> *Syms
= Entry
.Symbols
.get
<std::vector
<MCSymbol
*>*>();
184 for (unsigned i
= 0, e
= Syms
->size(); i
!= e
; ++i
) {
185 MCSymbol
*Sym
= (*Syms
)[i
];
186 if (Sym
->isDefined()) continue; // Ignore already emitted labels.
188 // If the block is not yet defined, we need to emit it at the end of the
189 // function. Add the symbol to the DeletedAddrLabelsNeedingEmission list
190 // for the containing Function. Since the block is being deleted, its
191 // parent may already be removed, we have to get the function from
193 DeletedAddrLabelsNeedingEmission
[Entry
.Fn
].push_back(Sym
);
196 // The entry is deleted, free the memory associated with the symbol list.
201 void MMIAddrLabelMap::UpdateForRAUWBlock(BasicBlock
*Old
, BasicBlock
*New
) {
202 // Get the entry for the RAUW'd block and remove it from our map.
203 AddrLabelSymEntry OldEntry
= AddrLabelSymbols
[Old
];
204 AddrLabelSymbols
.erase(Old
);
205 assert(!OldEntry
.Symbols
.isNull() && "Didn't have a symbol, why a callback?");
207 AddrLabelSymEntry
&NewEntry
= AddrLabelSymbols
[New
];
209 // If New is not address taken, just move our symbol over to it.
210 if (NewEntry
.Symbols
.isNull()) {
211 BBCallbacks
[OldEntry
.Index
].setPtr(New
); // Update the callback.
212 NewEntry
= OldEntry
; // Set New's entry.
216 BBCallbacks
[OldEntry
.Index
] = nullptr; // Update the callback.
218 // Otherwise, we need to add the old symbol to the new block's set. If it is
219 // just a single entry, upgrade it to a symbol list.
220 if (MCSymbol
*PrevSym
= NewEntry
.Symbols
.dyn_cast
<MCSymbol
*>()) {
221 std::vector
<MCSymbol
*> *SymList
= new std::vector
<MCSymbol
*>();
222 SymList
->push_back(PrevSym
);
223 NewEntry
.Symbols
= SymList
;
226 std::vector
<MCSymbol
*> *SymList
=
227 NewEntry
.Symbols
.get
<std::vector
<MCSymbol
*>*>();
229 // If the old entry was a single symbol, add it.
230 if (MCSymbol
*Sym
= OldEntry
.Symbols
.dyn_cast
<MCSymbol
*>()) {
231 SymList
->push_back(Sym
);
235 // Otherwise, concatenate the list.
236 std::vector
<MCSymbol
*> *Syms
=OldEntry
.Symbols
.get
<std::vector
<MCSymbol
*>*>();
237 SymList
->insert(SymList
->end(), Syms
->begin(), Syms
->end());
242 void MMIAddrLabelMapCallbackPtr::deleted() {
243 Map
->UpdateForDeletedBlock(cast
<BasicBlock
>(getValPtr()));
246 void MMIAddrLabelMapCallbackPtr::allUsesReplacedWith(Value
*V2
) {
247 Map
->UpdateForRAUWBlock(cast
<BasicBlock
>(getValPtr()), cast
<BasicBlock
>(V2
));
251 //===----------------------------------------------------------------------===//
253 MachineModuleInfo::MachineModuleInfo(const MCAsmInfo
&MAI
,
254 const MCRegisterInfo
&MRI
,
255 const MCObjectFileInfo
*MOFI
)
256 : ImmutablePass(ID
), Context(&MAI
, &MRI
, MOFI
, nullptr, false) {
257 initializeMachineModuleInfoPass(*PassRegistry::getPassRegistry());
260 MachineModuleInfo::MachineModuleInfo()
261 : ImmutablePass(ID
), Context(nullptr, nullptr, nullptr) {
262 llvm_unreachable("This MachineModuleInfo constructor should never be called, "
263 "MMI should always be explicitly constructed by "
264 "LLVMTargetMachine");
267 MachineModuleInfo::~MachineModuleInfo() {
270 bool MachineModuleInfo::doInitialization(Module
&M
) {
272 ObjFileMMI
= nullptr;
276 DbgInfoAvailable
= UsesVAFloatArgument
= UsesMorestackAddr
= false;
277 // Always emit some info, by default "no personality" info.
278 Personalities
.push_back(nullptr);
279 AddrLabelSymbols
= nullptr;
285 bool MachineModuleInfo::doFinalization(Module
&M
) {
287 Personalities
.clear();
289 delete AddrLabelSymbols
;
290 AddrLabelSymbols
= nullptr;
295 ObjFileMMI
= nullptr;
300 /// EndFunction - Discard function meta information.
302 void MachineModuleInfo::EndFunction() {
303 // Clean up frame info.
304 FrameInstructions
.clear();
306 // Clean up exception info.
314 VariableDbgInfos
.clear();
317 /// AnalyzeModule - Scan the module for global debug information.
319 void MachineModuleInfo::AnalyzeModule(const Module
&M
) {
320 // Insert functions in the llvm.used array (but not llvm.compiler.used) into
322 const GlobalVariable
*GV
= M
.getGlobalVariable("llvm.used");
323 if (!GV
|| !GV
->hasInitializer()) return;
325 // Should be an array of 'i8*'.
326 const ConstantArray
*InitList
= cast
<ConstantArray
>(GV
->getInitializer());
328 for (unsigned i
= 0, e
= InitList
->getNumOperands(); i
!= e
; ++i
)
329 if (const Function
*F
=
330 dyn_cast
<Function
>(InitList
->getOperand(i
)->stripPointerCasts()))
331 UsedFunctions
.insert(F
);
334 //===- Address of Block Management ----------------------------------------===//
337 /// getAddrLabelSymbol - Return the symbol to be used for the specified basic
338 /// block when its address is taken. This cannot be its normal LBB label
339 /// because the block may be accessed outside its containing function.
340 MCSymbol
*MachineModuleInfo::getAddrLabelSymbol(const BasicBlock
*BB
) {
341 // Lazily create AddrLabelSymbols.
342 if (!AddrLabelSymbols
)
343 AddrLabelSymbols
= new MMIAddrLabelMap(Context
);
344 return AddrLabelSymbols
->getAddrLabelSymbol(const_cast<BasicBlock
*>(BB
));
347 /// getAddrLabelSymbolToEmit - Return the symbol to be used for the specified
348 /// basic block when its address is taken. If other blocks were RAUW'd to
349 /// this one, we may have to emit them as well, return the whole set.
350 std::vector
<MCSymbol
*> MachineModuleInfo::
351 getAddrLabelSymbolToEmit(const BasicBlock
*BB
) {
352 // Lazily create AddrLabelSymbols.
353 if (!AddrLabelSymbols
)
354 AddrLabelSymbols
= new MMIAddrLabelMap(Context
);
355 return AddrLabelSymbols
->getAddrLabelSymbolToEmit(const_cast<BasicBlock
*>(BB
));
359 /// takeDeletedSymbolsForFunction - If the specified function has had any
360 /// references to address-taken blocks generated, but the block got deleted,
361 /// return the symbol now so we can emit it. This prevents emitting a
362 /// reference to a symbol that has no definition.
363 void MachineModuleInfo::
364 takeDeletedSymbolsForFunction(const Function
*F
,
365 std::vector
<MCSymbol
*> &Result
) {
366 // If no blocks have had their addresses taken, we're done.
367 if (!AddrLabelSymbols
) return;
368 return AddrLabelSymbols
->
369 takeDeletedSymbolsForFunction(const_cast<Function
*>(F
), Result
);
372 //===- EH -----------------------------------------------------------------===//
374 /// getOrCreateLandingPadInfo - Find or create an LandingPadInfo for the
375 /// specified MachineBasicBlock.
376 LandingPadInfo
&MachineModuleInfo::getOrCreateLandingPadInfo
377 (MachineBasicBlock
*LandingPad
) {
378 unsigned N
= LandingPads
.size();
379 for (unsigned i
= 0; i
< N
; ++i
) {
380 LandingPadInfo
&LP
= LandingPads
[i
];
381 if (LP
.LandingPadBlock
== LandingPad
)
385 LandingPads
.push_back(LandingPadInfo(LandingPad
));
386 return LandingPads
[N
];
389 /// addInvoke - Provide the begin and end labels of an invoke style call and
390 /// associate it with a try landing pad block.
391 void MachineModuleInfo::addInvoke(MachineBasicBlock
*LandingPad
,
392 MCSymbol
*BeginLabel
, MCSymbol
*EndLabel
) {
393 LandingPadInfo
&LP
= getOrCreateLandingPadInfo(LandingPad
);
394 LP
.BeginLabels
.push_back(BeginLabel
);
395 LP
.EndLabels
.push_back(EndLabel
);
398 /// addLandingPad - Provide the label of a try LandingPad block.
400 MCSymbol
*MachineModuleInfo::addLandingPad(MachineBasicBlock
*LandingPad
) {
401 MCSymbol
*LandingPadLabel
= Context
.CreateTempSymbol();
402 LandingPadInfo
&LP
= getOrCreateLandingPadInfo(LandingPad
);
403 LP
.LandingPadLabel
= LandingPadLabel
;
404 return LandingPadLabel
;
407 /// addPersonality - Provide the personality function for the exception
409 void MachineModuleInfo::addPersonality(MachineBasicBlock
*LandingPad
,
410 const Function
*Personality
) {
411 LandingPadInfo
&LP
= getOrCreateLandingPadInfo(LandingPad
);
412 LP
.Personality
= Personality
;
414 for (unsigned i
= 0; i
< Personalities
.size(); ++i
)
415 if (Personalities
[i
] == Personality
)
418 // If this is the first personality we're adding go
419 // ahead and add it at the beginning.
420 if (!Personalities
[0])
421 Personalities
[0] = Personality
;
423 Personalities
.push_back(Personality
);
426 /// addCatchTypeInfo - Provide the catch typeinfo for a landing pad.
428 void MachineModuleInfo::
429 addCatchTypeInfo(MachineBasicBlock
*LandingPad
,
430 ArrayRef
<const GlobalValue
*> TyInfo
) {
431 LandingPadInfo
&LP
= getOrCreateLandingPadInfo(LandingPad
);
432 for (unsigned N
= TyInfo
.size(); N
; --N
)
433 LP
.TypeIds
.push_back(getTypeIDFor(TyInfo
[N
- 1]));
436 /// addFilterTypeInfo - Provide the filter typeinfo for a landing pad.
438 void MachineModuleInfo::
439 addFilterTypeInfo(MachineBasicBlock
*LandingPad
,
440 ArrayRef
<const GlobalValue
*> TyInfo
) {
441 LandingPadInfo
&LP
= getOrCreateLandingPadInfo(LandingPad
);
442 std::vector
<unsigned> IdsInFilter(TyInfo
.size());
443 for (unsigned I
= 0, E
= TyInfo
.size(); I
!= E
; ++I
)
444 IdsInFilter
[I
] = getTypeIDFor(TyInfo
[I
]);
445 LP
.TypeIds
.push_back(getFilterIDFor(IdsInFilter
));
448 /// addCleanup - Add a cleanup action for a landing pad.
450 void MachineModuleInfo::addCleanup(MachineBasicBlock
*LandingPad
) {
451 LandingPadInfo
&LP
= getOrCreateLandingPadInfo(LandingPad
);
452 LP
.TypeIds
.push_back(0);
455 /// TidyLandingPads - Remap landing pad labels and remove any deleted landing
457 void MachineModuleInfo::TidyLandingPads(DenseMap
<MCSymbol
*, uintptr_t> *LPMap
) {
458 for (unsigned i
= 0; i
!= LandingPads
.size(); ) {
459 LandingPadInfo
&LandingPad
= LandingPads
[i
];
460 if (LandingPad
.LandingPadLabel
&&
461 !LandingPad
.LandingPadLabel
->isDefined() &&
462 (!LPMap
|| (*LPMap
)[LandingPad
.LandingPadLabel
] == 0))
463 LandingPad
.LandingPadLabel
= nullptr;
465 // Special case: we *should* emit LPs with null LP MBB. This indicates
467 if (!LandingPad
.LandingPadLabel
&& LandingPad
.LandingPadBlock
) {
468 LandingPads
.erase(LandingPads
.begin() + i
);
472 for (unsigned j
= 0, e
= LandingPads
[i
].BeginLabels
.size(); j
!= e
; ++j
) {
473 MCSymbol
*BeginLabel
= LandingPad
.BeginLabels
[j
];
474 MCSymbol
*EndLabel
= LandingPad
.EndLabels
[j
];
475 if ((BeginLabel
->isDefined() ||
476 (LPMap
&& (*LPMap
)[BeginLabel
] != 0)) &&
477 (EndLabel
->isDefined() ||
478 (LPMap
&& (*LPMap
)[EndLabel
] != 0))) continue;
480 LandingPad
.BeginLabels
.erase(LandingPad
.BeginLabels
.begin() + j
);
481 LandingPad
.EndLabels
.erase(LandingPad
.EndLabels
.begin() + j
);
485 // Remove landing pads with no try-ranges.
486 if (LandingPads
[i
].BeginLabels
.empty()) {
487 LandingPads
.erase(LandingPads
.begin() + i
);
491 // If there is no landing pad, ensure that the list of typeids is empty.
492 // If the only typeid is a cleanup, this is the same as having no typeids.
493 if (!LandingPad
.LandingPadBlock
||
494 (LandingPad
.TypeIds
.size() == 1 && !LandingPad
.TypeIds
[0]))
495 LandingPad
.TypeIds
.clear();
500 /// setCallSiteLandingPad - Map the landing pad's EH symbol to the call site
502 void MachineModuleInfo::setCallSiteLandingPad(MCSymbol
*Sym
,
503 ArrayRef
<unsigned> Sites
) {
504 LPadToCallSiteMap
[Sym
].append(Sites
.begin(), Sites
.end());
507 /// getTypeIDFor - Return the type id for the specified typeinfo. This is
509 unsigned MachineModuleInfo::getTypeIDFor(const GlobalValue
*TI
) {
510 for (unsigned i
= 0, N
= TypeInfos
.size(); i
!= N
; ++i
)
511 if (TypeInfos
[i
] == TI
) return i
+ 1;
513 TypeInfos
.push_back(TI
);
514 return TypeInfos
.size();
517 /// getFilterIDFor - Return the filter id for the specified typeinfos. This is
519 int MachineModuleInfo::getFilterIDFor(std::vector
<unsigned> &TyIds
) {
520 // If the new filter coincides with the tail of an existing filter, then
521 // re-use the existing filter. Folding filters more than this requires
522 // re-ordering filters and/or their elements - probably not worth it.
523 for (std::vector
<unsigned>::iterator I
= FilterEnds
.begin(),
524 E
= FilterEnds
.end(); I
!= E
; ++I
) {
525 unsigned i
= *I
, j
= TyIds
.size();
528 if (FilterIds
[--i
] != TyIds
[--j
])
532 // The new filter coincides with range [i, end) of the existing filter.
538 // Add the new filter.
539 int FilterID
= -(1 + FilterIds
.size());
540 FilterIds
.reserve(FilterIds
.size() + TyIds
.size() + 1);
541 FilterIds
.insert(FilterIds
.end(), TyIds
.begin(), TyIds
.end());
542 FilterEnds
.push_back(FilterIds
.size());
543 FilterIds
.push_back(0); // terminator
547 /// getPersonality - Return the personality function for the current function.
548 const Function
*MachineModuleInfo::getPersonality() const {
549 // FIXME: Until PR1414 will be fixed, we're using 1 personality function per
551 return !LandingPads
.empty() ? LandingPads
[0].Personality
: nullptr;
554 /// getPersonalityIndex - Return unique index for current personality
555 /// function. NULL/first personality function should always get zero index.
556 unsigned MachineModuleInfo::getPersonalityIndex() const {
557 const Function
* Personality
= nullptr;
559 // Scan landing pads. If there is at least one non-NULL personality - use it.
560 for (unsigned i
= 0, e
= LandingPads
.size(); i
!= e
; ++i
)
561 if (LandingPads
[i
].Personality
) {
562 Personality
= LandingPads
[i
].Personality
;
566 for (unsigned i
= 0, e
= Personalities
.size(); i
< e
; ++i
) {
567 if (Personalities
[i
] == Personality
)
571 // This will happen if the current personality function is
572 // in the zero index.