]>
Commit | Line | Data |
---|---|---|
1a4d82fc | 1 | //===-- CodeGen/AsmPrinter/EHStreamer.cpp - Exception Directive Streamer --===// |
223e47cc LB |
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 | // | |
1a4d82fc | 10 | // This file contains support for writing exception info into assembly files. |
223e47cc LB |
11 | // |
12 | //===----------------------------------------------------------------------===// | |
13 | ||
1a4d82fc | 14 | #include "EHStreamer.h" |
223e47cc | 15 | #include "llvm/CodeGen/AsmPrinter.h" |
223e47cc | 16 | #include "llvm/CodeGen/MachineFunction.h" |
1a4d82fc | 17 | #include "llvm/CodeGen/MachineInstr.h" |
970d7e83 | 18 | #include "llvm/CodeGen/MachineModuleInfo.h" |
1a4d82fc | 19 | #include "llvm/IR/Function.h" |
223e47cc | 20 | #include "llvm/MC/MCAsmInfo.h" |
223e47cc LB |
21 | #include "llvm/MC/MCStreamer.h" |
22 | #include "llvm/MC/MCSymbol.h" | |
1a4d82fc | 23 | #include "llvm/Support/LEB128.h" |
223e47cc | 24 | #include "llvm/Target/TargetLoweringObjectFile.h" |
1a4d82fc | 25 | |
223e47cc LB |
26 | using namespace llvm; |
27 | ||
1a4d82fc | 28 | EHStreamer::EHStreamer(AsmPrinter *A) : Asm(A), MMI(Asm->MMI) {} |
223e47cc | 29 | |
1a4d82fc | 30 | EHStreamer::~EHStreamer() {} |
223e47cc | 31 | |
1a4d82fc JJ |
32 | /// How many leading type ids two landing pads have in common. |
33 | unsigned EHStreamer::sharedTypeIDs(const LandingPadInfo *L, | |
34 | const LandingPadInfo *R) { | |
223e47cc LB |
35 | const std::vector<int> &LIds = L->TypeIds, &RIds = R->TypeIds; |
36 | unsigned LSize = LIds.size(), RSize = RIds.size(); | |
37 | unsigned MinSize = LSize < RSize ? LSize : RSize; | |
38 | unsigned Count = 0; | |
39 | ||
40 | for (; Count != MinSize; ++Count) | |
41 | if (LIds[Count] != RIds[Count]) | |
42 | return Count; | |
43 | ||
44 | return Count; | |
45 | } | |
46 | ||
1a4d82fc JJ |
47 | /// Compute the actions table and gather the first action index for each landing |
48 | /// pad site. | |
49 | unsigned EHStreamer:: | |
50 | computeActionsTable(const SmallVectorImpl<const LandingPadInfo*> &LandingPads, | |
223e47cc LB |
51 | SmallVectorImpl<ActionEntry> &Actions, |
52 | SmallVectorImpl<unsigned> &FirstActions) { | |
53 | ||
54 | // The action table follows the call-site table in the LSDA. The individual | |
55 | // records are of two types: | |
56 | // | |
57 | // * Catch clause | |
58 | // * Exception specification | |
59 | // | |
60 | // The two record kinds have the same format, with only small differences. | |
61 | // They are distinguished by the "switch value" field: Catch clauses | |
62 | // (TypeInfos) have strictly positive switch values, and exception | |
63 | // specifications (FilterIds) have strictly negative switch values. Value 0 | |
64 | // indicates a catch-all clause. | |
65 | // | |
66 | // Negative type IDs index into FilterIds. Positive type IDs index into | |
67 | // TypeInfos. The value written for a positive type ID is just the type ID | |
68 | // itself. For a negative type ID, however, the value written is the | |
69 | // (negative) byte offset of the corresponding FilterIds entry. The byte | |
70 | // offset is usually equal to the type ID (because the FilterIds entries are | |
71 | // written using a variable width encoding, which outputs one byte per entry | |
72 | // as long as the value written is not too large) but can differ. This kind | |
73 | // of complication does not occur for positive type IDs because type infos are | |
74 | // output using a fixed width encoding. FilterOffsets[i] holds the byte | |
75 | // offset corresponding to FilterIds[i]. | |
76 | ||
77 | const std::vector<unsigned> &FilterIds = MMI->getFilterIds(); | |
78 | SmallVector<int, 16> FilterOffsets; | |
79 | FilterOffsets.reserve(FilterIds.size()); | |
80 | int Offset = -1; | |
81 | ||
82 | for (std::vector<unsigned>::const_iterator | |
83 | I = FilterIds.begin(), E = FilterIds.end(); I != E; ++I) { | |
84 | FilterOffsets.push_back(Offset); | |
1a4d82fc | 85 | Offset -= getULEB128Size(*I); |
223e47cc LB |
86 | } |
87 | ||
88 | FirstActions.reserve(LandingPads.size()); | |
89 | ||
90 | int FirstAction = 0; | |
91 | unsigned SizeActions = 0; | |
1a4d82fc | 92 | const LandingPadInfo *PrevLPI = nullptr; |
223e47cc LB |
93 | |
94 | for (SmallVectorImpl<const LandingPadInfo *>::const_iterator | |
95 | I = LandingPads.begin(), E = LandingPads.end(); I != E; ++I) { | |
96 | const LandingPadInfo *LPI = *I; | |
97 | const std::vector<int> &TypeIds = LPI->TypeIds; | |
1a4d82fc | 98 | unsigned NumShared = PrevLPI ? sharedTypeIDs(LPI, PrevLPI) : 0; |
223e47cc LB |
99 | unsigned SizeSiteActions = 0; |
100 | ||
101 | if (NumShared < TypeIds.size()) { | |
102 | unsigned SizeAction = 0; | |
103 | unsigned PrevAction = (unsigned)-1; | |
104 | ||
105 | if (NumShared) { | |
106 | unsigned SizePrevIds = PrevLPI->TypeIds.size(); | |
107 | assert(Actions.size()); | |
108 | PrevAction = Actions.size() - 1; | |
1a4d82fc JJ |
109 | SizeAction = getSLEB128Size(Actions[PrevAction].NextAction) + |
110 | getSLEB128Size(Actions[PrevAction].ValueForTypeID); | |
223e47cc LB |
111 | |
112 | for (unsigned j = NumShared; j != SizePrevIds; ++j) { | |
113 | assert(PrevAction != (unsigned)-1 && "PrevAction is invalid!"); | |
1a4d82fc | 114 | SizeAction -= getSLEB128Size(Actions[PrevAction].ValueForTypeID); |
223e47cc LB |
115 | SizeAction += -Actions[PrevAction].NextAction; |
116 | PrevAction = Actions[PrevAction].Previous; | |
117 | } | |
118 | } | |
119 | ||
120 | // Compute the actions. | |
121 | for (unsigned J = NumShared, M = TypeIds.size(); J != M; ++J) { | |
122 | int TypeID = TypeIds[J]; | |
123 | assert(-1 - TypeID < (int)FilterOffsets.size() && "Unknown filter id!"); | |
124 | int ValueForTypeID = TypeID < 0 ? FilterOffsets[-1 - TypeID] : TypeID; | |
1a4d82fc | 125 | unsigned SizeTypeID = getSLEB128Size(ValueForTypeID); |
223e47cc LB |
126 | |
127 | int NextAction = SizeAction ? -(SizeAction + SizeTypeID) : 0; | |
1a4d82fc | 128 | SizeAction = SizeTypeID + getSLEB128Size(NextAction); |
223e47cc LB |
129 | SizeSiteActions += SizeAction; |
130 | ||
131 | ActionEntry Action = { ValueForTypeID, NextAction, PrevAction }; | |
132 | Actions.push_back(Action); | |
133 | PrevAction = Actions.size() - 1; | |
134 | } | |
135 | ||
136 | // Record the first action of the landing pad site. | |
137 | FirstAction = SizeActions + SizeSiteActions - SizeAction + 1; | |
138 | } // else identical - re-use previous FirstAction | |
139 | ||
140 | // Information used when created the call-site table. The action record | |
141 | // field of the call site record is the offset of the first associated | |
142 | // action record, relative to the start of the actions table. This value is | |
143 | // biased by 1 (1 indicating the start of the actions table), and 0 | |
144 | // indicates that there are no actions. | |
145 | FirstActions.push_back(FirstAction); | |
146 | ||
147 | // Compute this sites contribution to size. | |
148 | SizeActions += SizeSiteActions; | |
149 | ||
150 | PrevLPI = LPI; | |
151 | } | |
152 | ||
153 | return SizeActions; | |
154 | } | |
155 | ||
1a4d82fc JJ |
156 | /// Return `true' if this is a call to a function marked `nounwind'. Return |
157 | /// `false' otherwise. | |
158 | bool EHStreamer::callToNoUnwindFunction(const MachineInstr *MI) { | |
223e47cc LB |
159 | assert(MI->isCall() && "This should be a call instruction!"); |
160 | ||
161 | bool MarkedNoUnwind = false; | |
162 | bool SawFunc = false; | |
163 | ||
164 | for (unsigned I = 0, E = MI->getNumOperands(); I != E; ++I) { | |
165 | const MachineOperand &MO = MI->getOperand(I); | |
166 | ||
167 | if (!MO.isGlobal()) continue; | |
168 | ||
169 | const Function *F = dyn_cast<Function>(MO.getGlobal()); | |
1a4d82fc | 170 | if (!F) continue; |
223e47cc LB |
171 | |
172 | if (SawFunc) { | |
173 | // Be conservative. If we have more than one function operand for this | |
174 | // call, then we can't make the assumption that it's the callee and | |
175 | // not a parameter to the call. | |
176 | // | |
177 | // FIXME: Determine if there's a way to say that `F' is the callee or | |
178 | // parameter. | |
179 | MarkedNoUnwind = false; | |
180 | break; | |
181 | } | |
182 | ||
183 | MarkedNoUnwind = F->doesNotThrow(); | |
184 | SawFunc = true; | |
185 | } | |
186 | ||
187 | return MarkedNoUnwind; | |
188 | } | |
189 | ||
1a4d82fc JJ |
190 | /// Compute the call-site table. The entry for an invoke has a try-range |
191 | /// containing the call, a non-zero landing pad, and an appropriate action. The | |
192 | /// entry for an ordinary call has a try-range containing the call and zero for | |
193 | /// the landing pad and the action. Calls marked 'nounwind' have no entry and | |
194 | /// must not be contained in the try-range of any entry - they form gaps in the | |
195 | /// table. Entries must be ordered by try-range address. | |
196 | void EHStreamer:: | |
197 | computeCallSiteTable(SmallVectorImpl<CallSiteEntry> &CallSites, | |
223e47cc LB |
198 | const RangeMapType &PadMap, |
199 | const SmallVectorImpl<const LandingPadInfo *> &LandingPads, | |
200 | const SmallVectorImpl<unsigned> &FirstActions) { | |
201 | // The end label of the previous invoke or nounwind try-range. | |
1a4d82fc | 202 | MCSymbol *LastLabel = nullptr; |
223e47cc LB |
203 | |
204 | // Whether there is a potentially throwing instruction (currently this means | |
205 | // an ordinary call) between the end of the previous try-range and now. | |
206 | bool SawPotentiallyThrowing = false; | |
207 | ||
208 | // Whether the last CallSite entry was for an invoke. | |
209 | bool PreviousIsInvoke = false; | |
210 | ||
211 | // Visit all instructions in order of address. | |
1a4d82fc JJ |
212 | for (const auto &MBB : *Asm->MF) { |
213 | for (const auto &MI : MBB) { | |
214 | if (!MI.isEHLabel()) { | |
215 | if (MI.isCall()) | |
216 | SawPotentiallyThrowing |= !callToNoUnwindFunction(&MI); | |
223e47cc LB |
217 | continue; |
218 | } | |
219 | ||
220 | // End of the previous try-range? | |
1a4d82fc | 221 | MCSymbol *BeginLabel = MI.getOperand(0).getMCSymbol(); |
223e47cc LB |
222 | if (BeginLabel == LastLabel) |
223 | SawPotentiallyThrowing = false; | |
224 | ||
225 | // Beginning of a new try-range? | |
226 | RangeMapType::const_iterator L = PadMap.find(BeginLabel); | |
227 | if (L == PadMap.end()) | |
228 | // Nope, it was just some random label. | |
229 | continue; | |
230 | ||
231 | const PadRange &P = L->second; | |
232 | const LandingPadInfo *LandingPad = LandingPads[P.PadIndex]; | |
233 | assert(BeginLabel == LandingPad->BeginLabels[P.RangeIndex] && | |
234 | "Inconsistent landing pad map!"); | |
235 | ||
236 | // For Dwarf exception handling (SjLj handling doesn't use this). If some | |
237 | // instruction between the previous try-range and this one may throw, | |
238 | // create a call-site entry with no landing pad for the region between the | |
239 | // try-ranges. | |
240 | if (SawPotentiallyThrowing && Asm->MAI->isExceptionHandlingDwarf()) { | |
1a4d82fc | 241 | CallSiteEntry Site = { LastLabel, BeginLabel, nullptr, 0 }; |
223e47cc LB |
242 | CallSites.push_back(Site); |
243 | PreviousIsInvoke = false; | |
244 | } | |
245 | ||
246 | LastLabel = LandingPad->EndLabels[P.RangeIndex]; | |
247 | assert(BeginLabel && LastLabel && "Invalid landing pad!"); | |
248 | ||
249 | if (!LandingPad->LandingPadLabel) { | |
250 | // Create a gap. | |
251 | PreviousIsInvoke = false; | |
252 | } else { | |
253 | // This try-range is for an invoke. | |
254 | CallSiteEntry Site = { | |
255 | BeginLabel, | |
256 | LastLabel, | |
257 | LandingPad->LandingPadLabel, | |
258 | FirstActions[P.PadIndex] | |
259 | }; | |
260 | ||
261 | // Try to merge with the previous call-site. SJLJ doesn't do this | |
262 | if (PreviousIsInvoke && Asm->MAI->isExceptionHandlingDwarf()) { | |
263 | CallSiteEntry &Prev = CallSites.back(); | |
264 | if (Site.PadLabel == Prev.PadLabel && Site.Action == Prev.Action) { | |
265 | // Extend the range of the previous entry. | |
266 | Prev.EndLabel = Site.EndLabel; | |
267 | continue; | |
268 | } | |
269 | } | |
270 | ||
271 | // Otherwise, create a new call-site. | |
272 | if (Asm->MAI->isExceptionHandlingDwarf()) | |
273 | CallSites.push_back(Site); | |
274 | else { | |
275 | // SjLj EH must maintain the call sites in the order assigned | |
276 | // to them by the SjLjPrepare pass. | |
277 | unsigned SiteNo = MMI->getCallSiteBeginLabel(BeginLabel); | |
278 | if (CallSites.size() < SiteNo) | |
279 | CallSites.resize(SiteNo); | |
280 | CallSites[SiteNo - 1] = Site; | |
281 | } | |
282 | PreviousIsInvoke = true; | |
283 | } | |
284 | } | |
285 | } | |
286 | ||
287 | // If some instruction between the previous try-range and the end of the | |
288 | // function may throw, create a call-site entry with no landing pad for the | |
289 | // region following the try-range. | |
290 | if (SawPotentiallyThrowing && Asm->MAI->isExceptionHandlingDwarf()) { | |
1a4d82fc | 291 | CallSiteEntry Site = { LastLabel, nullptr, nullptr, 0 }; |
223e47cc LB |
292 | CallSites.push_back(Site); |
293 | } | |
294 | } | |
295 | ||
1a4d82fc | 296 | /// Emit landing pads and actions. |
223e47cc LB |
297 | /// |
298 | /// The general organization of the table is complex, but the basic concepts are | |
299 | /// easy. First there is a header which describes the location and organization | |
300 | /// of the three components that follow. | |
301 | /// | |
302 | /// 1. The landing pad site information describes the range of code covered by | |
303 | /// the try. In our case it's an accumulation of the ranges covered by the | |
304 | /// invokes in the try. There is also a reference to the landing pad that | |
305 | /// handles the exception once processed. Finally an index into the actions | |
306 | /// table. | |
307 | /// 2. The action table, in our case, is composed of pairs of type IDs and next | |
308 | /// action offset. Starting with the action index from the landing pad | |
309 | /// site, each type ID is checked for a match to the current exception. If | |
310 | /// it matches then the exception and type id are passed on to the landing | |
311 | /// pad. Otherwise the next action is looked up. This chain is terminated | |
312 | /// with a next action of zero. If no type id is found then the frame is | |
313 | /// unwound and handling continues. | |
314 | /// 3. Type ID table contains references to all the C++ typeinfo for all | |
315 | /// catches in the function. This tables is reverse indexed base 1. | |
1a4d82fc | 316 | void EHStreamer::emitExceptionTable() { |
223e47cc LB |
317 | const std::vector<const GlobalVariable *> &TypeInfos = MMI->getTypeInfos(); |
318 | const std::vector<unsigned> &FilterIds = MMI->getFilterIds(); | |
319 | const std::vector<LandingPadInfo> &PadInfos = MMI->getLandingPads(); | |
320 | ||
321 | // Sort the landing pads in order of their type ids. This is used to fold | |
322 | // duplicate actions. | |
323 | SmallVector<const LandingPadInfo *, 64> LandingPads; | |
324 | LandingPads.reserve(PadInfos.size()); | |
325 | ||
326 | for (unsigned i = 0, N = PadInfos.size(); i != N; ++i) | |
327 | LandingPads.push_back(&PadInfos[i]); | |
328 | ||
1a4d82fc JJ |
329 | // Order landing pads lexicographically by type id. |
330 | std::sort(LandingPads.begin(), LandingPads.end(), | |
331 | [](const LandingPadInfo *L, | |
332 | const LandingPadInfo *R) { return L->TypeIds < R->TypeIds; }); | |
223e47cc LB |
333 | |
334 | // Compute the actions table and gather the first action index for each | |
335 | // landing pad site. | |
336 | SmallVector<ActionEntry, 32> Actions; | |
337 | SmallVector<unsigned, 64> FirstActions; | |
1a4d82fc JJ |
338 | unsigned SizeActions = |
339 | computeActionsTable(LandingPads, Actions, FirstActions); | |
223e47cc LB |
340 | |
341 | // Invokes and nounwind calls have entries in PadMap (due to being bracketed | |
342 | // by try-range labels when lowered). Ordinary calls do not, so appropriate | |
343 | // try-ranges for them need be deduced when using DWARF exception handling. | |
344 | RangeMapType PadMap; | |
345 | for (unsigned i = 0, N = LandingPads.size(); i != N; ++i) { | |
346 | const LandingPadInfo *LandingPad = LandingPads[i]; | |
347 | for (unsigned j = 0, E = LandingPad->BeginLabels.size(); j != E; ++j) { | |
348 | MCSymbol *BeginLabel = LandingPad->BeginLabels[j]; | |
349 | assert(!PadMap.count(BeginLabel) && "Duplicate landing pad labels!"); | |
350 | PadRange P = { i, j }; | |
351 | PadMap[BeginLabel] = P; | |
352 | } | |
353 | } | |
354 | ||
355 | // Compute the call-site table. | |
356 | SmallVector<CallSiteEntry, 64> CallSites; | |
1a4d82fc | 357 | computeCallSiteTable(CallSites, PadMap, LandingPads, FirstActions); |
223e47cc LB |
358 | |
359 | // Final tallies. | |
360 | ||
361 | // Call sites. | |
362 | bool IsSJLJ = Asm->MAI->getExceptionHandlingType() == ExceptionHandling::SjLj; | |
363 | bool HaveTTData = IsSJLJ ? (!TypeInfos.empty() || !FilterIds.empty()) : true; | |
364 | ||
365 | unsigned CallSiteTableLength; | |
366 | if (IsSJLJ) | |
367 | CallSiteTableLength = 0; | |
368 | else { | |
369 | unsigned SiteStartSize = 4; // dwarf::DW_EH_PE_udata4 | |
370 | unsigned SiteLengthSize = 4; // dwarf::DW_EH_PE_udata4 | |
371 | unsigned LandingPadSize = 4; // dwarf::DW_EH_PE_udata4 | |
372 | CallSiteTableLength = | |
373 | CallSites.size() * (SiteStartSize + SiteLengthSize + LandingPadSize); | |
374 | } | |
375 | ||
376 | for (unsigned i = 0, e = CallSites.size(); i < e; ++i) { | |
1a4d82fc | 377 | CallSiteTableLength += getULEB128Size(CallSites[i].Action); |
223e47cc | 378 | if (IsSJLJ) |
1a4d82fc | 379 | CallSiteTableLength += getULEB128Size(i); |
223e47cc LB |
380 | } |
381 | ||
382 | // Type infos. | |
383 | const MCSection *LSDASection = Asm->getObjFileLowering().getLSDASection(); | |
384 | unsigned TTypeEncoding; | |
385 | unsigned TypeFormatSize; | |
386 | ||
387 | if (!HaveTTData) { | |
388 | // For SjLj exceptions, if there is no TypeInfo, then we just explicitly say | |
389 | // that we're omitting that bit. | |
390 | TTypeEncoding = dwarf::DW_EH_PE_omit; | |
391 | // dwarf::DW_EH_PE_absptr | |
970d7e83 | 392 | TypeFormatSize = Asm->getDataLayout().getPointerSize(); |
223e47cc LB |
393 | } else { |
394 | // Okay, we have actual filters or typeinfos to emit. As such, we need to | |
395 | // pick a type encoding for them. We're about to emit a list of pointers to | |
396 | // typeinfo objects at the end of the LSDA. However, unless we're in static | |
397 | // mode, this reference will require a relocation by the dynamic linker. | |
398 | // | |
399 | // Because of this, we have a couple of options: | |
400 | // | |
401 | // 1) If we are in -static mode, we can always use an absolute reference | |
402 | // from the LSDA, because the static linker will resolve it. | |
403 | // | |
404 | // 2) Otherwise, if the LSDA section is writable, we can output the direct | |
405 | // reference to the typeinfo and allow the dynamic linker to relocate | |
406 | // it. Since it is in a writable section, the dynamic linker won't | |
407 | // have a problem. | |
408 | // | |
409 | // 3) Finally, if we're in PIC mode and the LDSA section isn't writable, | |
410 | // we need to use some form of indirection. For example, on Darwin, | |
411 | // we can output a statically-relocatable reference to a dyld stub. The | |
412 | // offset to the stub is constant, but the contents are in a section | |
413 | // that is updated by the dynamic linker. This is easy enough, but we | |
414 | // need to tell the personality function of the unwinder to indirect | |
415 | // through the dyld stub. | |
416 | // | |
417 | // FIXME: When (3) is actually implemented, we'll have to emit the stubs | |
418 | // somewhere. This predicate should be moved to a shared location that is | |
419 | // in target-independent code. | |
420 | // | |
421 | TTypeEncoding = Asm->getObjFileLowering().getTTypeEncoding(); | |
422 | TypeFormatSize = Asm->GetSizeOfEncodedValue(TTypeEncoding); | |
423 | } | |
424 | ||
425 | // Begin the exception table. | |
426 | // Sometimes we want not to emit the data into separate section (e.g. ARM | |
427 | // EHABI). In this case LSDASection will be NULL. | |
428 | if (LSDASection) | |
429 | Asm->OutStreamer.SwitchSection(LSDASection); | |
430 | Asm->EmitAlignment(2); | |
431 | ||
432 | // Emit the LSDA. | |
433 | MCSymbol *GCCETSym = | |
434 | Asm->OutContext.GetOrCreateSymbol(Twine("GCC_except_table")+ | |
435 | Twine(Asm->getFunctionNumber())); | |
436 | Asm->OutStreamer.EmitLabel(GCCETSym); | |
437 | Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("exception", | |
438 | Asm->getFunctionNumber())); | |
439 | ||
440 | if (IsSJLJ) | |
441 | Asm->OutStreamer.EmitLabel(Asm->GetTempSymbol("_LSDA_", | |
442 | Asm->getFunctionNumber())); | |
443 | ||
444 | // Emit the LSDA header. | |
445 | Asm->EmitEncodingByte(dwarf::DW_EH_PE_omit, "@LPStart"); | |
446 | Asm->EmitEncodingByte(TTypeEncoding, "@TType"); | |
447 | ||
448 | // The type infos need to be aligned. GCC does this by inserting padding just | |
449 | // before the type infos. However, this changes the size of the exception | |
450 | // table, so you need to take this into account when you output the exception | |
451 | // table size. However, the size is output using a variable length encoding. | |
452 | // So by increasing the size by inserting padding, you may increase the number | |
453 | // of bytes used for writing the size. If it increases, say by one byte, then | |
454 | // you now need to output one less byte of padding to get the type infos | |
455 | // aligned. However this decreases the size of the exception table. This | |
456 | // changes the value you have to output for the exception table size. Due to | |
457 | // the variable length encoding, the number of bytes used for writing the | |
458 | // length may decrease. If so, you then have to increase the amount of | |
459 | // padding. And so on. If you look carefully at the GCC code you will see that | |
460 | // it indeed does this in a loop, going on and on until the values stabilize. | |
461 | // We chose another solution: don't output padding inside the table like GCC | |
462 | // does, instead output it before the table. | |
463 | unsigned SizeTypes = TypeInfos.size() * TypeFormatSize; | |
1a4d82fc | 464 | unsigned CallSiteTableLengthSize = getULEB128Size(CallSiteTableLength); |
223e47cc LB |
465 | unsigned TTypeBaseOffset = |
466 | sizeof(int8_t) + // Call site format | |
467 | CallSiteTableLengthSize + // Call site table length size | |
468 | CallSiteTableLength + // Call site table length | |
469 | SizeActions + // Actions size | |
470 | SizeTypes; | |
1a4d82fc | 471 | unsigned TTypeBaseOffsetSize = getULEB128Size(TTypeBaseOffset); |
223e47cc LB |
472 | unsigned TotalSize = |
473 | sizeof(int8_t) + // LPStart format | |
474 | sizeof(int8_t) + // TType format | |
475 | (HaveTTData ? TTypeBaseOffsetSize : 0) + // TType base offset size | |
476 | TTypeBaseOffset; // TType base offset | |
477 | unsigned SizeAlign = (4 - TotalSize) & 3; | |
478 | ||
479 | if (HaveTTData) { | |
480 | // Account for any extra padding that will be added to the call site table | |
481 | // length. | |
482 | Asm->EmitULEB128(TTypeBaseOffset, "@TType base offset", SizeAlign); | |
483 | SizeAlign = 0; | |
484 | } | |
485 | ||
486 | bool VerboseAsm = Asm->OutStreamer.isVerboseAsm(); | |
487 | ||
488 | // SjLj Exception handling | |
489 | if (IsSJLJ) { | |
490 | Asm->EmitEncodingByte(dwarf::DW_EH_PE_udata4, "Call site"); | |
491 | ||
492 | // Add extra padding if it wasn't added to the TType base offset. | |
493 | Asm->EmitULEB128(CallSiteTableLength, "Call site table length", SizeAlign); | |
494 | ||
495 | // Emit the landing pad site information. | |
496 | unsigned idx = 0; | |
497 | for (SmallVectorImpl<CallSiteEntry>::const_iterator | |
498 | I = CallSites.begin(), E = CallSites.end(); I != E; ++I, ++idx) { | |
499 | const CallSiteEntry &S = *I; | |
500 | ||
501 | // Offset of the landing pad, counted in 16-byte bundles relative to the | |
502 | // @LPStart address. | |
503 | if (VerboseAsm) { | |
504 | Asm->OutStreamer.AddComment(">> Call Site " + Twine(idx) + " <<"); | |
505 | Asm->OutStreamer.AddComment(" On exception at call site "+Twine(idx)); | |
506 | } | |
507 | Asm->EmitULEB128(idx); | |
508 | ||
509 | // Offset of the first associated action record, relative to the start of | |
510 | // the action table. This value is biased by 1 (1 indicates the start of | |
511 | // the action table), and 0 indicates that there are no actions. | |
512 | if (VerboseAsm) { | |
513 | if (S.Action == 0) | |
514 | Asm->OutStreamer.AddComment(" Action: cleanup"); | |
515 | else | |
516 | Asm->OutStreamer.AddComment(" Action: " + | |
517 | Twine((S.Action - 1) / 2 + 1)); | |
518 | } | |
519 | Asm->EmitULEB128(S.Action); | |
520 | } | |
521 | } else { | |
522 | // DWARF Exception handling | |
523 | assert(Asm->MAI->isExceptionHandlingDwarf()); | |
524 | ||
525 | // The call-site table is a list of all call sites that may throw an | |
526 | // exception (including C++ 'throw' statements) in the procedure | |
527 | // fragment. It immediately follows the LSDA header. Each entry indicates, | |
528 | // for a given call, the first corresponding action record and corresponding | |
529 | // landing pad. | |
530 | // | |
531 | // The table begins with the number of bytes, stored as an LEB128 | |
532 | // compressed, unsigned integer. The records immediately follow the record | |
533 | // count. They are sorted in increasing call-site address. Each record | |
534 | // indicates: | |
535 | // | |
536 | // * The position of the call-site. | |
537 | // * The position of the landing pad. | |
538 | // * The first action record for that call site. | |
539 | // | |
540 | // A missing entry in the call-site table indicates that a call is not | |
541 | // supposed to throw. | |
542 | ||
543 | // Emit the landing pad call site table. | |
544 | Asm->EmitEncodingByte(dwarf::DW_EH_PE_udata4, "Call site"); | |
545 | ||
546 | // Add extra padding if it wasn't added to the TType base offset. | |
547 | Asm->EmitULEB128(CallSiteTableLength, "Call site table length", SizeAlign); | |
548 | ||
549 | unsigned Entry = 0; | |
550 | for (SmallVectorImpl<CallSiteEntry>::const_iterator | |
551 | I = CallSites.begin(), E = CallSites.end(); I != E; ++I) { | |
552 | const CallSiteEntry &S = *I; | |
553 | ||
554 | MCSymbol *EHFuncBeginSym = | |
555 | Asm->GetTempSymbol("eh_func_begin", Asm->getFunctionNumber()); | |
556 | ||
557 | MCSymbol *BeginLabel = S.BeginLabel; | |
1a4d82fc | 558 | if (!BeginLabel) |
223e47cc LB |
559 | BeginLabel = EHFuncBeginSym; |
560 | MCSymbol *EndLabel = S.EndLabel; | |
1a4d82fc | 561 | if (!EndLabel) |
223e47cc LB |
562 | EndLabel = Asm->GetTempSymbol("eh_func_end", Asm->getFunctionNumber()); |
563 | ||
564 | ||
565 | // Offset of the call site relative to the previous call site, counted in | |
566 | // number of 16-byte bundles. The first call site is counted relative to | |
567 | // the start of the procedure fragment. | |
568 | if (VerboseAsm) | |
569 | Asm->OutStreamer.AddComment(">> Call Site " + Twine(++Entry) + " <<"); | |
570 | Asm->EmitLabelDifference(BeginLabel, EHFuncBeginSym, 4); | |
571 | if (VerboseAsm) | |
572 | Asm->OutStreamer.AddComment(Twine(" Call between ") + | |
573 | BeginLabel->getName() + " and " + | |
574 | EndLabel->getName()); | |
575 | Asm->EmitLabelDifference(EndLabel, BeginLabel, 4); | |
576 | ||
577 | // Offset of the landing pad, counted in 16-byte bundles relative to the | |
578 | // @LPStart address. | |
579 | if (!S.PadLabel) { | |
580 | if (VerboseAsm) | |
581 | Asm->OutStreamer.AddComment(" has no landing pad"); | |
970d7e83 | 582 | Asm->OutStreamer.EmitIntValue(0, 4/*size*/); |
223e47cc LB |
583 | } else { |
584 | if (VerboseAsm) | |
585 | Asm->OutStreamer.AddComment(Twine(" jumps to ") + | |
586 | S.PadLabel->getName()); | |
587 | Asm->EmitLabelDifference(S.PadLabel, EHFuncBeginSym, 4); | |
588 | } | |
589 | ||
590 | // Offset of the first associated action record, relative to the start of | |
591 | // the action table. This value is biased by 1 (1 indicates the start of | |
592 | // the action table), and 0 indicates that there are no actions. | |
593 | if (VerboseAsm) { | |
594 | if (S.Action == 0) | |
595 | Asm->OutStreamer.AddComment(" On action: cleanup"); | |
596 | else | |
597 | Asm->OutStreamer.AddComment(" On action: " + | |
598 | Twine((S.Action - 1) / 2 + 1)); | |
599 | } | |
600 | Asm->EmitULEB128(S.Action); | |
601 | } | |
602 | } | |
603 | ||
604 | // Emit the Action Table. | |
605 | int Entry = 0; | |
606 | for (SmallVectorImpl<ActionEntry>::const_iterator | |
607 | I = Actions.begin(), E = Actions.end(); I != E; ++I) { | |
608 | const ActionEntry &Action = *I; | |
609 | ||
610 | if (VerboseAsm) { | |
611 | // Emit comments that decode the action table. | |
612 | Asm->OutStreamer.AddComment(">> Action Record " + Twine(++Entry) + " <<"); | |
613 | } | |
614 | ||
615 | // Type Filter | |
616 | // | |
617 | // Used by the runtime to match the type of the thrown exception to the | |
618 | // type of the catch clauses or the types in the exception specification. | |
619 | if (VerboseAsm) { | |
620 | if (Action.ValueForTypeID > 0) | |
621 | Asm->OutStreamer.AddComment(" Catch TypeInfo " + | |
622 | Twine(Action.ValueForTypeID)); | |
623 | else if (Action.ValueForTypeID < 0) | |
624 | Asm->OutStreamer.AddComment(" Filter TypeInfo " + | |
625 | Twine(Action.ValueForTypeID)); | |
626 | else | |
627 | Asm->OutStreamer.AddComment(" Cleanup"); | |
628 | } | |
629 | Asm->EmitSLEB128(Action.ValueForTypeID); | |
630 | ||
631 | // Action Record | |
632 | // | |
633 | // Self-relative signed displacement in bytes of the next action record, | |
634 | // or 0 if there is no next action record. | |
635 | if (VerboseAsm) { | |
636 | if (Action.NextAction == 0) { | |
637 | Asm->OutStreamer.AddComment(" No further actions"); | |
638 | } else { | |
639 | unsigned NextAction = Entry + (Action.NextAction + 1) / 2; | |
640 | Asm->OutStreamer.AddComment(" Continue to action "+Twine(NextAction)); | |
641 | } | |
642 | } | |
643 | Asm->EmitSLEB128(Action.NextAction); | |
644 | } | |
645 | ||
1a4d82fc | 646 | emitTypeInfos(TTypeEncoding); |
970d7e83 LB |
647 | |
648 | Asm->EmitAlignment(2); | |
649 | } | |
650 | ||
1a4d82fc | 651 | void EHStreamer::emitTypeInfos(unsigned TTypeEncoding) { |
970d7e83 LB |
652 | const std::vector<const GlobalVariable *> &TypeInfos = MMI->getTypeInfos(); |
653 | const std::vector<unsigned> &FilterIds = MMI->getFilterIds(); | |
654 | ||
655 | bool VerboseAsm = Asm->OutStreamer.isVerboseAsm(); | |
656 | ||
657 | int Entry = 0; | |
223e47cc LB |
658 | // Emit the Catch TypeInfos. |
659 | if (VerboseAsm && !TypeInfos.empty()) { | |
660 | Asm->OutStreamer.AddComment(">> Catch TypeInfos <<"); | |
661 | Asm->OutStreamer.AddBlankLine(); | |
662 | Entry = TypeInfos.size(); | |
663 | } | |
664 | ||
665 | for (std::vector<const GlobalVariable *>::const_reverse_iterator | |
666 | I = TypeInfos.rbegin(), E = TypeInfos.rend(); I != E; ++I) { | |
667 | const GlobalVariable *GV = *I; | |
668 | if (VerboseAsm) | |
669 | Asm->OutStreamer.AddComment("TypeInfo " + Twine(Entry--)); | |
970d7e83 | 670 | Asm->EmitTTypeReference(GV, TTypeEncoding); |
223e47cc LB |
671 | } |
672 | ||
673 | // Emit the Exception Specifications. | |
674 | if (VerboseAsm && !FilterIds.empty()) { | |
675 | Asm->OutStreamer.AddComment(">> Filter TypeInfos <<"); | |
676 | Asm->OutStreamer.AddBlankLine(); | |
677 | Entry = 0; | |
678 | } | |
679 | for (std::vector<unsigned>::const_iterator | |
680 | I = FilterIds.begin(), E = FilterIds.end(); I < E; ++I) { | |
681 | unsigned TypeID = *I; | |
682 | if (VerboseAsm) { | |
683 | --Entry; | |
684 | if (TypeID != 0) | |
685 | Asm->OutStreamer.AddComment("FilterInfo " + Twine(Entry)); | |
686 | } | |
687 | ||
688 | Asm->EmitULEB128(TypeID); | |
689 | } | |
223e47cc LB |
690 | } |
691 | ||
1a4d82fc JJ |
692 | /// Emit all exception information that should come after the content. |
693 | void EHStreamer::endModule() { | |
223e47cc LB |
694 | llvm_unreachable("Should be implemented"); |
695 | } | |
696 | ||
1a4d82fc JJ |
697 | /// Gather pre-function exception information. Assumes it's being emitted |
698 | /// immediately after the function entry point. | |
699 | void EHStreamer::beginFunction(const MachineFunction *MF) { | |
223e47cc LB |
700 | llvm_unreachable("Should be implemented"); |
701 | } | |
702 | ||
1a4d82fc JJ |
703 | /// Gather and emit post-function exception information. |
704 | void EHStreamer::endFunction(const MachineFunction *) { | |
223e47cc LB |
705 | llvm_unreachable("Should be implemented"); |
706 | } |