Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / external / llvm / e15192b36bb5e99838d3f70bf79f7b8bed7a75b9 / . / docs / ExceptionHandling.html
blob: 6ec6ab8233eda346e9f77d1fe5b46912af363670 [file] [log] [blame]
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]1<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"
2 "http://www.w3.org/TR/html4/strict.dtd">
3<html>
4<head>
5 <title>Exception Handling in LLVM</title>
6 <link rel="stylesheet" href="llvm.css" type="text/css">
7</head>
8<body>
9
10<div class="doc_title">Exception Handling in LLVM</div>
11
12<table class="layout" style="width:100%">
13 <tr class="layout">
14 <td class="left">
15<ul>
16 <li><a href="#introduction">Introduction</a>
17 <ol>
18 <li><a href="#itanium">Itanium ABI Zero-cost Exception Handling</a></li>
19 <li><a href="#overview">Overview</a></li>
20 </ol></li>
21 <li><a href="#codegen">LLVM Code Generation</a>
22 <ol>
23 <li><a href="#throw">Throw</a></li>
24 <li><a href="#try_catch">Try/Catch</a></li>
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]25 <li><a href="#cleanups">Cleanups</a></li>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]26 <li><a href="#throw_filters">Throw Filters</a></li>
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]27 <li><a href="#restrictions">Restrictions</a></li>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]28 </ol></li>
Duncan Sands8036ca42007-03-30 12:22:09 +0000[diff] [blame]29 <li><a href="#format_common_intrinsics">Exception Handling Intrinsics</a>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]30 <ol>
31 <li><a href="#llvm_eh_exception"><tt>llvm.eh.exception</tt></a></li>
32 <li><a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a></li>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]33 <li><a href="#llvm_eh_typeid_for"><tt>llvm.eh.typeid.for</tt></a></li>
Jim Grosbachf9570122009-05-14 00:46:35 +0000[diff] [blame]34 <li><a href="#llvm_eh_sjlj_setjmp"><tt>llvm.eh.sjlj.setjmp</tt></a></li>
35 <li><a href="#llvm_eh_sjlj_longjmp"><tt>llvm.eh.sjlj.longjmp</tt></a></li>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]36 </ol></li>
37 <li><a href="#asm">Asm Table Formats</a>
38 <ol>
39 <li><a href="#unwind_tables">Exception Handling Frame</a></li>
40 <li><a href="#exception_tables">Exception Tables</a></li>
41 </ol></li>
42 <li><a href="#todo">ToDo</a></li>
43</ul>
44</td>
45</tr></table>
46
47<div class="doc_author">
48 <p>Written by <a href="mailto:jlaskey@mac.com">Jim Laskey</a></p>
49</div>
50
51
52<!-- *********************************************************************** -->
53<div class="doc_section"><a name="introduction">Introduction</a></div>
54<!-- *********************************************************************** -->
55
56<div class="doc_text">
57
58<p>This document is the central repository for all information pertaining to
59exception handling in LLVM. It describes the format that LLVM exception
60handling information takes, which is useful for those interested in creating
61front-ends or dealing directly with the information. Further, this document
62provides specific examples of what exception handling information is used for
63C/C++.</p>
64
65</div>
66
67<!-- ======================================================================= -->
68<div class="doc_subsection">
69 <a name="itanium">Itanium ABI Zero-cost Exception Handling</a>
70</div>
71
72<div class="doc_text">
73
74<p>Exception handling for most programming languages is designed to recover from
75conditions that rarely occur during general use of an application. To that end,
76exception handling should not interfere with the main flow of an
Bill Wendlingd40bc4a2007-09-22 10:17:08 +0000[diff] [blame]77application's algorithm by performing checkpointing tasks such as saving
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]78the current pc or register state.</p>
79
80<p>The Itanium ABI Exception Handling Specification defines a methodology for
81providing outlying data in the form of exception tables without inlining
Bill Wendlingd40bc4a2007-09-22 10:17:08 +0000[diff] [blame]82speculative exception handling code in the flow of an application's main
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]83algorithm. Thus, the specification is said to add "zero-cost" to the normal
84execution of an application.</p>
85
86<p>A more complete description of the Itanium ABI exception handling runtime
87support of can be found at <a
88href="http://www.codesourcery.com/cxx-abi/abi-eh.html">Itanium C++ ABI:
Bill Wendlingd40bc4a2007-09-22 10:17:08 +0000[diff] [blame]89Exception Handling.</a> A description of the exception frame format can be found
90at <a href="http://refspecs.freestandards.org/LSB_3.0.0/LSB-Core-generic/LSB-
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]91Core-generic/ehframechpt.html">Exception Frames</a>, with details of the Dwarf
92specification at <a href="http://www.eagercon.com/dwarf/dwarf3std.htm">Dwarf 3
93Standard.</a> A description for the C++ exception table formats can be found at
94<a href="http://www.codesourcery.com/cxx-abi/exceptions.pdf">Exception Handling
95Tables.</a></p>
96
97</div>
98
99<!-- ======================================================================= -->
100<div class="doc_subsection">
101 <a name="overview">Overview</a>
102</div>
103
104<div class="doc_text">
105
106<p>When an exception is thrown in llvm code, the runtime does a best effort to
107find a handler suited to process the circumstance.</p>
108
109<p>The runtime first attempts to find an <i>exception frame</i> corresponding to
110the function where the exception was thrown. If the programming language (ex.
111C++) supports exception handling, the exception frame contains a reference to an
112exception table describing how to process the exception. If the language (ex.
113C) does not support exception handling or if the exception needs to be forwarded
114to a prior activation, the exception frame contains information about how to
115unwind the current activation and restore the state of the prior activation.
116This process is repeated until the exception is handled. If the exception is
117not handled and no activations remain, then the application is terminated with
118an appropriate error message.</p>
119
120<p>Since different programming languages have different behaviors when handling
121exceptions, the exception handling ABI provides a mechanism for supplying
122<i>personalities.</i> An exception handling personality is defined by way of a
123<i>personality function</i> (ex. for C++ <tt>__gxx_personality_v0</tt>) which
124receives the context of the exception, an <i>exception structure</i> containing
Duncan Sandsfb0a64a2007-04-16 13:02:27 +0000[diff] [blame]125the exception object type and value, and a reference to the exception table for
126the current function. The personality function for the current compile unit is
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]127specified in a <i>common exception frame</i>.</p>
128
129<p>The organization of an exception table is language dependent. For C++, an
130exception table is organized as a series of code ranges defining what to do if
131an exception occurs in that range. Typically, the information associated with a
132range defines which types of exception objects (using C++ <i>type info</i>) that
133are handled in that range, and an associated action that should take place.
134Actions typically pass control to a <i>landing pad</i>.</p>
135
136<p>A landing pad corresponds to the code found in the catch portion of a
137try/catch sequence. When execution resumes at a landing pad, it receives the
138exception structure and a selector corresponding to the <i>type</i> of exception
139thrown. The selector is then used to determine which catch should actually
140process the exception.</p>
141
142</div>
143
144<!-- ======================================================================= -->
145<div class="doc_section">
146 <a name="codegen">LLVM Code Generation</a>
147</div>
148
149<div class="doc_text">
150
151<p>At the time of this writing, only C++ exception handling support is available
152in LLVM. So the remainder of this document will be somewhat C++-centric.</p>
153
154<p>From the C++ developers perspective, exceptions are defined in terms of the
155<tt>throw</tt> and <tt>try/catch</tt> statements. In this section we will
156describe the implementation of llvm exception handling in terms of C++
157examples.</p>
158
159</div>
160
161<!-- ======================================================================= -->
162<div class="doc_subsection">
163 <a name="throw">Throw</a>
164</div>
165
166<div class="doc_text">
167
168<p>Languages that support exception handling typically provide a <tt>throw</tt>
169operation to initiate the exception process. Internally, a throw operation
170breaks down into two steps. First, a request is made to allocate exception
171space for an exception structure. This structure needs to survive beyond the
172current activation. This structure will contain the type and value of the
173object being thrown. Second, a call is made to the runtime to raise the
174exception, passing the exception structure as an argument.</p>
175
176<p>In C++, the allocation of the exception structure is done by the
177<tt>__cxa_allocate_exception</tt> runtime function. The exception raising is
178handled by <tt>__cxa_throw</tt>. The type of the exception is represented using
179a C++ RTTI type info structure.</p>
180
181</div>
182
183<!-- ======================================================================= -->
184<div class="doc_subsection">
185 <a name="try_catch">Try/Catch</a>
186</div>
187
188<div class="doc_text">
189
Duncan Sandsb0a1cbf2007-04-14 12:30:27 +0000[diff] [blame]190<p>A call within the scope of a try statement can potentially raise an exception.
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]191In those circumstances, the LLVM C++ front-end replaces the call with an
192<tt>invoke</tt> instruction. Unlike a call, the invoke has two potential
193continuation points; where to continue when the call succeeds as per normal, and
194where to continue if the call raises an exception, either by a throw or the
195unwinding of a throw.</p>
196
197<p>The term used to define a the place where an invoke continues after an
198exception is called a <i>landing pad</i>. LLVM landing pads are conceptually
Duncan Sandsfb0a64a2007-04-16 13:02:27 +0000[diff] [blame]199alternative function entry points where a exception structure reference and a type
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]200info index are passed in as arguments. The landing pad saves the exception
201structure reference and then proceeds to select the catch block that corresponds
202to the type info of the exception object.</p>
203
204<p>Two llvm intrinsic functions are used convey information about the landing
205pad to the back end.</p>
206
207<p><a href="#llvm_eh_exception"><tt>llvm.eh.exception</tt></a> takes no
Duncan Sands6531d472008-12-29 15:27:32 +0000[diff] [blame]208arguments and returns a pointer to the exception structure. This only returns a
209sensible value if called after an invoke has branched to a landing pad. Due to
210codegen limitations, it must currently be called in the landing pad itself.</p>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]211
212<p><a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> takes a minimum of
213three arguments. The first argument is the reference to the exception
214structure. The second argument is a reference to the personality function to be
Duncan Sandscf26d7c2007-07-04 20:52:51 +0000[diff] [blame]215used for this try catch sequence. Each of the remaining arguments is either a
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]216reference to the type info for a catch statement,
217a <a href="#throw_filters">filter</a> expression,
218or the number zero representing a <a href="#cleanups">cleanup</a>.
Duncan Sandscf26d7c2007-07-04 20:52:51 +0000[diff] [blame]219The exception is tested against the arguments sequentially from first to last.
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]220The result of the <a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> is a
221positive number if the exception matched a type info, a negative number if it matched
222a filter, and zero if it matched a cleanup. If nothing is matched, the behaviour of
223the program is <a href="#restrictions">undefined</a>.
Duncan Sands6531d472008-12-29 15:27:32 +0000[diff] [blame]224This only returns a sensible value if called after an invoke has branched to a
225landing pad. Due to codegen limitations, it must currently be called in the
226landing pad itself.
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]227If a type info matched then the selector value is the index of the type info in
228the exception table, which can be obtained using the
229<a href="#llvm_eh_typeid_for"><tt>llvm.eh.typeid.for</tt></a> intrinsic.</p>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]230
231<p>Once the landing pad has the type info selector, the code branches to the
232code for the first catch. The catch then checks the value of the type info
233selector against the index of type info for that catch. Since the type info
234index is not known until all the type info have been gathered in the backend,
235the catch code will call the <a
236href="#llvm_eh_typeid_for"><tt>llvm.eh.typeid.for</tt></a> intrinsic to
237determine the index for a given type info. If the catch fails to match the
238selector then control is passed on to the next catch. Note: Since the landing
239pad will not be used if there is no match in the list of type info on the call
240to <a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a>, then neither the
241last catch nor <i>catch all</i> need to perform the the check against the
242selector.</p>
243
244<p>Finally, the entry and exit of catch code is bracketed with calls to
245<tt>__cxa_begin_catch</tt> and <tt>__cxa_end_catch</tt>.
246<tt>__cxa_begin_catch</tt> takes a exception structure reference as an argument
Bill Wendlingd40bc4a2007-09-22 10:17:08 +0000[diff] [blame]247and returns the value of the exception object. <tt>__cxa_end_catch</tt>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]248takes a exception structure reference as an argument. This function clears the
249exception from the exception space. Note: a rethrow from within the catch may
250replace this call with a <tt>__cxa_rethrow</tt>.</p>
251
252</div>
253
254<!-- ======================================================================= -->
255<div class="doc_subsection">
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]256 <a name="cleanups">Cleanups</a>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]257</div>
258
259<div class="doc_text">
260
261<p>To handle destructors and cleanups in try code, control may not run directly
262from a landing pad to the first catch. Control may actually flow from the
263landing pad to clean up code and then to the first catch. Since the required
264clean up for each invoke in a try may be different (ex., intervening
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]265constructor), there may be several landing pads for a given try. If cleanups
266need to be run, the number zero should be passed as the last
267<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> argument.
268However for C++ a <tt>null i8*</tt> <a href="#restrictions">must</a> be passed
269instead.
270</p>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]271
272</div>
273
274<!-- ======================================================================= -->
275<div class="doc_subsection">
276 <a name="throw_filters">Throw Filters</a>
277</div>
278
279<div class="doc_text">
280
Duncan Sands6531d472008-12-29 15:27:32 +0000[diff] [blame]281<p>C++ allows the specification of which exception types can be thrown from
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]282a function. To represent this a top level landing pad may exist to filter out
283invalid types. To express this in LLVM code the landing pad will call <a
Duncan Sands6531d472008-12-29 15:27:32 +0000[diff] [blame]284href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a>. The arguments are a
285reference to the exception structure, a reference to the personality function,
286the length of the filter expression (the number of type infos plus one),
287followed by the type infos themselves.
Duncan Sandscf26d7c2007-07-04 20:52:51 +0000[diff] [blame]288<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> will return a negative
289value if the exception does not match any of the type infos. If no match is
290found then a call to <tt>__cxa_call_unexpected</tt> should be made, otherwise
Duncan Sands6531d472008-12-29 15:27:32 +0000[diff] [blame]291<tt>_Unwind_Resume</tt>. Each of these functions requires a reference to the
292exception structure. Note that the most general form of an
293<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> call can contain
294any number of type infos, filter expressions and cleanups (though having more
295than one cleanup is pointless). The LLVM C++ front-end can generate such
296<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> calls due to inlining
297creating nested exception handling scopes.</p>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]298
299</div>
300
301<!-- ======================================================================= -->
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]302<div class="doc_subsection">
303 <a name="restrictions">Restrictions</a>
304</div>
305
306<div class="doc_text">
307
308<p>The semantics of the invoke instruction require that any exception that
309unwinds through an invoke call should result in a branch to the invoke's unwind
310label. However such a branch will only happen if the
311<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> matches.
312Thus in order to ensure correct operation, the front-end must only generate
313<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> calls that are
314guaranteed to always match whatever exception unwinds through the invoke.
315For most languages it is enough to pass zero, indicating the presence of
316a <a href="#cleanups">cleanup</a>, as the last
317<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> argument.
318However for C++ this is not sufficient, because the C++ personality function
319will terminate the program if it detects that unwinding the exception only
320results in matches with cleanups. For C++ a <tt>null i8*</tt> should
321be passed as the last
322<a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> argument instead.
323This is interpreted as a catch-all by the C++ personality function, and will
324always match.
325</p>
326
327</div>
328
329<!-- ======================================================================= -->
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]330<div class="doc_section">
Duncan Sands8036ca42007-03-30 12:22:09 +0000[diff] [blame]331 <a name="format_common_intrinsics">Exception Handling Intrinsics</a>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]332</div>
333
334<div class="doc_text">
335
336<p>LLVM uses several intrinsic functions (name prefixed with "llvm.eh") to
337provide exception handling information at various points in generated code.</p>
338
339</div>
340
341<!-- ======================================================================= -->
342<div class="doc_subsubsection">
343 <a name="llvm_eh_exception">llvm.eh.exception</a>
344</div>
345
346<div class="doc_text">
347<pre>
348 i8* %<a href="#llvm_eh_exception">llvm.eh.exception</a>( )
349</pre>
350
Duncan Sands6531d472008-12-29 15:27:32 +0000[diff] [blame]351<p>This intrinsic returns a pointer to the exception structure.</p>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]352
353</div>
354
355<!-- ======================================================================= -->
356<div class="doc_subsubsection">
357 <a name="llvm_eh_selector">llvm.eh.selector</a>
358</div>
359
360<div class="doc_text">
361<pre>
Anton Korobeynikov8806c7b2007-09-07 11:39:35 +0000[diff] [blame]362 i32 %<a href="#llvm_eh_selector">llvm.eh.selector.i32</a>(i8*, i8*, i8*, ...)
363 i64 %<a href="#llvm_eh_selector">llvm.eh.selector.i64</a>(i8*, i8*, i8*, ...)
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]364</pre>
365
Duncan Sands6531d472008-12-29 15:27:32 +0000[diff] [blame]366<p>This intrinsic is used to compare the exception with the given type infos,
367filters and cleanups.</p>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]368
369<p><a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> takes a minimum of
370three arguments. The first argument is the reference to the exception
371structure. The second argument is a reference to the personality function to be
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]372used for this try catch sequence. Each of the remaining arguments is either a
373reference to the type info for a catch statement,
374a <a href="#throw_filters">filter</a> expression,
375or the number zero representing a <a href="#cleanups">cleanup</a>.
Duncan Sandscf26d7c2007-07-04 20:52:51 +0000[diff] [blame]376The exception is tested against the arguments sequentially from first to last.
Duncan Sands6590b042007-08-27 15:47:50 +0000[diff] [blame]377The result of the <a href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a> is a
378positive number if the exception matched a type info, a negative number if it matched
379a filter, and zero if it matched a cleanup. If nothing is matched, the behaviour of
380the program is <a href="#restrictions">undefined</a>.
381If a type info matched then the selector value is the index of the type info in
382the exception table, which can be obtained using the
383<a href="#llvm_eh_typeid_for"><tt>llvm.eh.typeid.for</tt></a> intrinsic.</p>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]384
385</div>
386
387<!-- ======================================================================= -->
388<div class="doc_subsubsection">
389 <a name="llvm_eh_typeid_for">llvm.eh.typeid.for</a>
390</div>
391
392<div class="doc_text">
393<pre>
Anton Korobeynikov8806c7b2007-09-07 11:39:35 +0000[diff] [blame]394 i32 %<a href="#llvm_eh_typeid_for">llvm.eh.typeid.for.i32</a>(i8*)
395 i64 %<a href="#llvm_eh_typeid_for">llvm.eh.typeid.for.i64</a>(i8*)
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]396</pre>
397
398<p>This intrinsic returns the type info index in the exception table of the
399current function. This value can be used to compare against the result of <a
400href="#llvm_eh_selector"><tt>llvm.eh.selector</tt></a>. The single argument is
401a reference to a type info.</p>
402
403</div>
404
405<!-- ======================================================================= -->
Jim Grosbachf9570122009-05-14 00:46:35 +0000[diff] [blame]406<div class="doc_subsubsection">
407 <a name="llvm_eh_sjlj_setjmp">llvm.eh.sjlj.setjmp</a>
408</div>
409
410<div class="doc_text">
411<pre>
412 i32 %<a href="#llvm_eh_sjlj_setjmp">llvm.eh.sjlj.setjmp</a>(i8*)
413</pre>
414
415<p>The SJLJ exception handling uses this intrinsic to force register saving
416for the current function and to store the address of the following instruction
417for use as a destination address by <a href="#llvm_eh_sjlj_setjmp">
418<tt>llvm.eh.sjlj.longjmp</tt></a>. The buffer format and the overall functioning
Jim Grosbach06261cd2009-05-14 15:44:15 +0000[diff] [blame]419of this intrinsic is compatible with the GCC <tt>__builtin_setjmp</tt>
420implementation, allowing code built with the two compilers to interoperate.</p>
Jim Grosbachf9570122009-05-14 00:46:35 +0000[diff] [blame]421
422<p>The single parameter is a pointer to a five word buffer in which the
423calling context is saved. The front end places the frame pointer in the
424first word, and the target implementation of this intrinsic should place the
425destination address for a <a href="#llvm_eh_sjlj_longjmp"><tt>
Jim Grosbach06261cd2009-05-14 15:44:15 +0000[diff] [blame]426llvm.eh.sjlj.longjmp</tt></a> in the second word. The following three words
427are available for use in a target-specific manner.</p>
Jim Grosbachf9570122009-05-14 00:46:35 +0000[diff] [blame]428
Benjamin Kramere15192b2009-08-05 15:42:44 +0000[diff] [blame^]429</div>
430
Jim Grosbachf9570122009-05-14 00:46:35 +0000[diff] [blame]431<!-- ======================================================================= -->
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]432<div class="doc_section">
433 <a name="asm">Asm Table Formats</a>
434</div>
435
436<div class="doc_text">
437
438<p>There are two tables that are used by the exception handling runtime to
439determine which actions should take place when an exception is thrown.</p>
440
441</div>
442
443<!-- ======================================================================= -->
444<div class="doc_subsection">
445 <a name="unwind_tables">Exception Handling Frame</a>
446</div>
447
448<div class="doc_text">
449
450<p>An exception handling frame <tt>eh_frame</tt> is very similar to the unwind
451frame used by dwarf debug info. The frame contains all the information
452necessary to tear down the current frame and restore the state of the prior
453frame. There is an exception handling frame for each function in a compile
454unit, plus a common exception handling frame that defines information common to
455all functions in the unit.</p>
456
457<p>Todo - Table details here.</p>
458
459</div>
460
461<!-- ======================================================================= -->
462<div class="doc_subsection">
463 <a name="exception_tables">Exception Tables</a>
464</div>
465
466<div class="doc_text">
467
468<p>An exception table contains information about what actions to take when an
Bill Wendlingd40bc4a2007-09-22 10:17:08 +0000[diff] [blame]469exception is thrown in a particular part of a function's code. There is
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]470one exception table per function except leaf routines and functions that have
471only calls to non-throwing functions will not need an exception table.</p>
472
473<p>Todo - Table details here.</p>
474
475</div>
476
477<!-- ======================================================================= -->
478<div class="doc_section">
479 <a name="todo">ToDo</a>
480</div>
481
482<div class="doc_text">
483
484<ol>
485
Bill Wendlingd40bc4a2007-09-22 10:17:08 +0000[diff] [blame]486<li><p>Testing/Testing/Testing.</p></li>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]487
488</ol>
489
490</div>
491
492<!-- *********************************************************************** -->
493
494<hr>
495<address>
496 <a href="http://jigsaw.w3.org/css-validator/check/referer"><img
Misha Brukman44408702008-12-11 17:34:48 +0000[diff] [blame]497 src="http://jigsaw.w3.org/css-validator/images/vcss-blue" alt="Valid CSS"></a>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]498 <a href="http://validator.w3.org/check/referer"><img
Misha Brukman44408702008-12-11 17:34:48 +0000[diff] [blame]499 src="http://www.w3.org/Icons/valid-html401-blue" alt="Valid HTML 4.01"></a>
Jim Laskeyd0d39b62007-03-14 19:29:42 +0000[diff] [blame]500
501 <a href="mailto:sabre@nondot.org">Chris Lattner</a><br>
502 <a href="http://llvm.org">LLVM Compiler Infrastructure</a><br>
503 Last modified: $Date$
504</address>
505
506</body>
507</html>