Changeset f28fdee
- Timestamp:
- Jan 20, 2021, 5:27:42 PM (4 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- Children:
- 09ee131
- Parents:
- 79e261b7
- Location:
- doc/theses/andrew_beach_MMath
- Files:
-
- 3 added
- 6 edited
-
Makefile (modified) (3 diffs)
-
existing.tex (modified) (20 diffs)
-
features.tex (modified) (14 diffs)
-
future.tex (modified) (2 diffs)
-
implement.tex (modified) (21 diffs)
-
unwinding.tex (modified) (9 diffs)
-
uw-ethesis-frontpgs.tex (added)
-
uw-ethesis.bib (added)
-
uw-thesis.tex (added)
Legend:
- Unmodified
- Added
- Removed
-
doc/theses/andrew_beach_MMath/Makefile
r79e261b7 rf28fdee 1 1 ### Makefile for Andrew Beach's Masters Thesis 2 2 3 DOC= thesis.pdf3 DOC=uw-thesis.pdf 4 4 BUILD=out 5 5 TEXSRC=$(wildcard *.tex) … … 7 7 STYSRC=$(wildcard *.sty) 8 8 CLSSRC=$(wildcard *.cls) 9 TEXLIB= .: ${BUILD}:9 TEXLIB= .:../../LaTeXmacros:${BUILD}: 10 10 BIBLIB= .:../../bibliography 11 11 … … 29 29 ${LATEX} ${BASE} 30 30 ${BIBTEX} ${BUILD}/${BASE} 31 ${LATEX} ${BASE} 31 32 ${GLOSSARY} ${BUILD}/${BASE} 32 33 ${LATEX} ${BASE} -
doc/theses/andrew_beach_MMath/existing.tex
r79e261b7 rf28fdee 1 \chapter{\CFA{} Existing Features} 1 \chapter{\CFA Existing Features} 2 3 \CFA (C-for-all)~\cite{Cforall} is an open-source project extending ISO C with modern safety and productivity features, while still ensuring backwards compatibility with C and its programmers. 4 \CFA is designed to have an orthogonal feature-set based closely on the C programming paradigm (non-object-oriented) and these features can be added incrementally to an existing C code-base allowing programmers to learn \CFA on an as-needed basis. 2 5 3 6 \section{Overloading and extern} 4 7 Cforall has overloading, allowing multiple definitions of the same name to 5 be defined. 8 be defined.~\cite{Moss18} 6 9 7 10 This also adds name mangling so that the assembly symbols are unique for … … 11 14 12 15 The syntax for disabling mangling is: 13 \begin{ lstlisting}16 \begin{cfa} 14 17 extern "C" { 15 18 ... 16 19 } 17 \end{ lstlisting}20 \end{cfa} 18 21 19 22 To re-enable mangling once it is disabled the syntax is: 20 \begin{ lstlisting}23 \begin{cfa} 21 24 extern "Cforall" { 22 25 ... 23 26 } 24 \end{ lstlisting}27 \end{cfa} 25 28 26 29 Both should occur at the declaration level and effect all the declarations 27 in \texttt{...}. Neither care about the state of mangling when they begin30 in @...@. Neither care about the state of mangling when they begin 28 31 and will return to that state after the group is finished. So re-enabling 29 32 is only used to nest areas of mangled and unmangled declarations. … … 31 34 \section{References} 32 35 \CFA adds references to C. These are auto-dereferencing pointers and use the 33 same syntax as pointers except they use ampersand ( \codeCFA{\&}) instead of34 the asterisk ( \codeCFA{*}). They can also be constaint or mutable, if they36 same syntax as pointers except they use ampersand (@&@) instead of 37 the asterisk (@*@). They can also be constaint or mutable, if they 35 38 are mutable they may be assigned to by using the address-of operator 36 ( \codeCFA\&) which converts them into a pointer.39 (@&@) which converts them into a pointer. 37 40 38 41 \section{Constructors and Destructors} … … 41 44 functions with special names. The special names are used to define them and 42 45 may be used to call the functions expicately. The \CFA special names are 43 constructed by taking the tokens in the operators and putting \texttt{?}where44 the arguments would go. So multiplication is \texttt{?*?}while dereference45 is \texttt{*?}. This also make it easy to tell the difference between46 pre-fix operations (such as \texttt{++?}) and post-fix operations47 ( \texttt{?++}).48 49 The special name for contructors is \texttt{?\{\}}, which comes from the46 constructed by taking the tokens in the operators and putting @?@ where 47 the arguments would go. So multiplication is @?*?@ while dereference 48 is @*?@. This also make it easy to tell the difference between 49 pre-fix operations (such as @++?@) and post-fix operations 50 (@?++@). 51 52 The special name for contructors is @?{}@, which comes from the 50 53 initialization syntax in C. The special name for destructors is 51 \texttt{\^{}?\{\}}. % I don't like the \^{} symbol but $^\wedge$ isn't better.54 @^{}@. % I don't like the \^{} symbol but $^\wedge$ isn't better. 52 55 53 56 Any time a type T goes out of scope the destructor matching 54 \codeCFA{void ^?\{\}(T \&);}is called. In theory this is also true of55 primitive types such as \codeCFA{int}, but in practice those are no-ops and57 @void ^?{}(T &);@ is called. In theory this is also true of 58 primitive types such as @int@, but in practice those are no-ops and 56 59 are usually omitted for optimization. 57 60 58 61 \section{Polymorphism} 59 62 \CFA uses polymorphism to create functions and types that are defined over 60 different types. \CFA polymorphic declarations serve the same role as \C PP63 different types. \CFA polymorphic declarations serve the same role as \CC 61 64 templates or Java generics. 62 65 … … 65 68 except that you may use the names introduced by the forall clause in them. 66 69 67 Forall clauses are written \codeCFA{forall( ... )} where \codeCFA{...}becomes70 Forall clauses are written @forall( ... )@ where @...@ becomes 68 71 the list of polymorphic variables (local type names) and assertions, which 69 72 repersent required operations on those types. 70 73 71 \begin{ lstlisting}74 \begin{cfa} 72 75 forall(dtype T | { void do_once(T &); }) 73 76 void do_twice(T & value) { … … 75 78 do_once(value); 76 79 } 77 \end{ lstlisting}80 \end{cfa} 78 81 79 82 A polymorphic function can be used in the same way normal functions are. … … 83 86 the the call site. 84 87 85 As an example, even if no function named \codeCFA{do_once}is not defined86 near the definition of \codeCFA{do_twice}the following code will work.87 \begin{ lstlisting}88 As an example, even if no function named @do_once@ is not defined 89 near the definition of @do_twice@ the following code will work. 90 \begin{cfa} 88 91 int quadruple(int x) { 89 92 void do_once(int & y) { … … 93 96 return x; 94 97 } 95 \end{ lstlisting}98 \end{cfa} 96 99 This is not the recommended way to implement a quadruple function but it 97 does work. The complier will deduce that \codeCFA{do_twice}'s T is an100 does work. The complier will deduce that @do_twice@'s T is an 98 101 integer from the argument. It will then look for a definition matching the 99 assertion which is the \codeCFA{do_once}defined within the function. That100 function will be passed in as a function pointer to \codeCFA{do_twice}and102 assertion which is the @do_once@ defined within the function. That 103 function will be passed in as a function pointer to @do_twice@ and 101 104 called within it. 102 105 … … 104 107 traits which collect assertions into convenent packages that can then be used 105 108 in assertion lists instead of all of their components. 106 \begin{ lstlisting}109 \begin{cfa} 107 110 trait done_once(dtype T) { 108 111 void do_once(T &); 109 112 } 110 \end{ lstlisting}113 \end{cfa} 111 114 112 115 After this the forall list in the previous example could instead be written 113 116 with the trait instead of the assertion itself. 114 \begin{ lstlisting}117 \begin{cfa} 115 118 forall(dtype T | done_once(T)) 116 \end{ lstlisting}119 \end{cfa} 117 120 118 121 Traits can have arbitrary number of assertions in them and are usually used to … … 124 127 are now used in field declaractions instead of parameters and local variables. 125 128 126 \begin{ lstlisting}129 \begin{cfa} 127 130 forall(dtype T) 128 131 struct node { … … 130 133 T * data; 131 134 } 132 \end{ lstlisting}133 134 The \codeCFA{node(T)}is a use of a polymorphic structure. Polymorphic types135 \end{cfa} 136 137 The @node(T)@ is a use of a polymorphic structure. Polymorphic types 135 138 must be provided their polymorphic parameters. 136 139 … … 140 143 \section{Concurrency} 141 144 142 \CFA has a number of concurrency features, \codeCFA{thread}s,143 \codeCFA{monitor}s and \codeCFA{mutex} parameters, \codeCFA{coroutine}s and144 \codeCFA{generator}s. The two features that interact with the exception system145 are \codeCFA{thread}s and \codeCFA{coroutine}s; they and their supporting145 \CFA has a number of concurrency features, @thread@s, 146 @monitor@s and @mutex@ parameters, @coroutine@s and 147 @generator@s. The two features that interact with the exception system 148 are @thread@s and @coroutine@s; they and their supporting 146 149 constructs will be described here. 147 150 … … 154 157 library. 155 158 156 In \CFA coroutines are created using the \codeCFA{coroutine}keyword which157 works just like \codeCFA{struct}except that the created structure will be158 modified by the compiler to satify the \codeCFA{is_coroutine}trait.159 In \CFA coroutines are created using the @coroutine@ keyword which 160 works just like @struct@ except that the created structure will be 161 modified by the compiler to satify the @is_coroutine@ trait. 159 162 160 163 These structures act as the interface between callers and the coroutine, 161 164 the fields are used to pass information in and out. Here is a simple example 162 165 where the single field is used to pass the next number in a sequence out. 163 \begin{ lstlisting}166 \begin{cfa} 164 167 coroutine CountUp { 165 168 unsigned int next; 166 169 } 167 \end{ lstlisting}170 \end{cfa} 168 171 169 172 The routine part of the coroutine is a main function for the coroutine. It … … 173 176 function it continue from that same suspend statement instead of at the top 174 177 of the function. 175 \begin{ lstlisting}178 \begin{cfa} 176 179 void main(CountUp & this) { 177 180 unsigned int next = 0; … … 182 185 } 183 186 } 184 \end{ lstlisting}187 \end{cfa} 185 188 186 189 Control is passed to the coroutine with the resume function. This includes the … … 189 192 return value is for easy access to communication variables. For example the 190 193 next value from a count-up can be generated and collected in a single 191 expression: \codeCFA{resume(count).next}.194 expression: @resume(count).next@. 192 195 193 196 \subsection{Monitors and Mutex} … … 198 201 parameters. 199 202 200 Function parameters can have the \codeCFA{mutex}qualifiers on reference201 arguments, for example \codeCFA{void example(a_monitor & mutex arg);}. When the203 Function parameters can have the @mutex@ qualifiers on reference 204 arguments, for example @void example(a_monitor & mutex arg);@. When the 202 205 function is called it will acquire the lock on all of the mutex parameters. 203 206 … … 214 217 215 218 Threads are created like coroutines except the keyword is changed: 216 \begin{ lstlisting}219 \begin{cfa} 217 220 thread StringWorker { 218 221 const char * input; … … 225 228 this.result = result; 226 229 } 227 \end{ lstlisting}230 \end{cfa} 228 231 The main function will start executing after the fork operation and continue 229 232 executing until it is finished. If another thread joins with this one it will … … 233 236 From the outside this is the creation and destruction of the thread object. 234 237 Fork happens after the constructor is run and join happens before the 235 destructor runs. Join also happens during the \codeCFA{join}function which238 destructor runs. Join also happens during the @join@ function which 236 239 can be used to join a thread earlier. If it is used the destructor does not 237 240 join as that has already been completed. -
doc/theses/andrew_beach_MMath/features.tex
r79e261b7 rf28fdee 54 54 returns a reference to the virtual table instance. Defining this function 55 55 also establishes the virtual type and virtual table pair to the resolver 56 and promises that \codeCFA{exceptT}is a virtual type and a child of the56 and promises that @exceptT@ is a virtual type and a child of the 57 57 base exception type. 58 58 59 One odd thing about \codeCFA{get_exception_vtable}is that it should always59 One odd thing about @get_exception_vtable@ is that it should always 60 60 be a constant function, returning the same value regardless of its argument. 61 61 A pointer or reference to the virtual table instance could be used instead, … … 66 66 67 67 Also note the use of the word ``promise" in the trait description. \CFA 68 cannot currently check to see if either \codeCFA{exceptT}or69 \codeCFA{virtualT}match the layout requirements. Currently this is70 considered part of \codeCFA{get_exception_vtable}'s correct implementation.68 cannot currently check to see if either @exceptT@ or 69 @virtualT@ match the layout requirements. Currently this is 70 considered part of @get_exception_vtable@'s correct implementation. 71 71 72 72 \begin{lstlisting} … … 92 92 93 93 Finally there are three additional macros that can be used to refer to the 94 these traits. They are \codeCFA{IS_EXCEPTION},95 \codeCFA{IS_TERMINATION_EXCEPTION} and \codeCFA{IS_RESUMPTION_EXCEPTION}.94 these traits. They are @IS_EXCEPTION@, 95 @IS_TERMINATION_EXCEPTION@ and @IS_RESUMPTION_EXCEPTION@. 96 96 Each takes the virtual type's name and, for polymorphic types only, the 97 97 parenthesized list of polymorphic arguments. These do the name mangling to … … 113 113 The expression must evaluate to a reference to a termination exception. A 114 114 termination exception is any exception with a 115 \codeCFA{void defaultTerminationHandler(T &);}(the default handler) defined115 @void defaultTerminationHandler(T &);@ (the default handler) defined 116 116 on it. The handler is taken from the call sight with \CFA's trait system and 117 117 passed into the exception system along with the exception itself. … … 169 169 170 170 You can also re-throw the most recent termination exception with 171 \codeCFA{throw;}. % This is terrible and you should never do it.171 @throw;@. % This is terrible and you should never do it. 172 172 This can be done in a handler or any function that could be called from a 173 173 handler. … … 193 193 The result of EXPRESSION must be a resumption exception type. A resumption 194 194 exception type is any type that satisfies the assertion 195 \codeCFA{void defaultResumptionHandler(T &);}(the default handler). When the195 @void defaultResumptionHandler(T &);@ (the default handler). When the 196 196 statement is executed the expression is evaluated and the result is thrown. 197 197 … … 260 260 \paragraph{Re-Throwing} 261 261 262 You may also re-throw resumptions with a \codeCFA{throwResume;}statement.263 This can only be done from inside of a \codeCFA{catchResume}block.262 You may also re-throw resumptions with a @throwResume;@ statement. 263 This can only be done from inside of a @catchResume@ block. 264 264 265 265 Outside of any side effects of any code already run in the handler this will … … 269 269 \section{Finally Clauses} 270 270 271 A \codeCFA{finally}clause may be placed at the end of a try statement after271 A @finally@ clause may be placed at the end of a try statement after 272 272 all the handler clauses. In the simply case, with no handlers, it looks like 273 273 this: … … 294 294 295 295 Because of this local control flow out of the finally block is forbidden. 296 The compiler rejects uses of \codeCFA{break}, \codeCFA{continue},297 \codeCFA{fallthru} and \codeCFA{return}that would cause control to leave296 The compiler rejects uses of @break@, @continue@, 297 @fallthru@ and @return@ that would cause control to leave 298 298 the finally block. Other ways to leave the finally block - such as a long 299 299 jump or termination - are much harder to check, at best requiring additional … … 307 307 308 308 There is no special statement for starting a cancellation, instead you call 309 the standard library function \codeCFA{cancel\_stack}which takes an exception.309 the standard library function @cancel\_stack@ which takes an exception. 310 310 Unlike in a throw this exception is not used in control flow but is just there 311 311 to pass information about why the cancellation happened. … … 323 323 324 324 \item Thread Stack: 325 Thread stacks are those created \codeCFA{thread}or otherwise satisfy the326 \codeCFA{is\_thread}trait.325 Thread stacks are those created @thread@ or otherwise satisfy the 326 @is\_thread@ trait. 327 327 328 328 Threads only have two structural points of communication that must happen, … … 333 333 and wait for another thread to join with it. The other thread, when it joins, 334 334 checks for a cancellation. If so it will throw the resumption exception 335 \codeCFA{ThreadCancelled}.336 337 There is a difference here in how explicate joins (with the \codeCFA{join}335 @ThreadCancelled@. 336 337 There is a difference here in how explicate joins (with the @join@ 338 338 function) and implicate joins (from a destructor call). Explicate joins will 339 take the default handler ( \codeCFA{defaultResumptionHandler}) from the context339 take the default handler (@defaultResumptionHandler@) from the context 340 340 and use like a regular through does if the exception is not caught. The 341 341 implicate join does a program abort instead. … … 349 349 350 350 \item Coroutine Stack: 351 Coroutine stacks are those created with \codeCFA{coroutine}or otherwise352 satisfy the \codeCFA{is\_coroutine}trait.351 Coroutine stacks are those created with @coroutine@ or otherwise 352 satisfy the @is\_coroutine@ trait. 353 353 354 354 A coroutine knows of two other coroutines, its starter and its last resumer. … … 356 356 357 357 After the stack is unwound control goes to the last resumer. 358 Resume will resume throw a \codeCFA{CoroutineCancelled}exception, which is358 Resume will resume throw a @CoroutineCancelled@ exception, which is 359 359 polymorphic over the coroutine type and has a pointer to the coroutine being 360 360 canceled and the canceling exception. The resume function also has an 361 assertion that the \codeCFA{defaultResumptionHandler}for the exception. So it361 assertion that the @defaultResumptionHandler@ for the exception. So it 362 362 will use the default handler like a regular throw. 363 363 -
doc/theses/andrew_beach_MMath/future.tex
r79e261b7 rf28fdee 20 20 21 21 \section{Additional Throws} 22 Several other kinds of throws, beyond the termination throw ( \codeCFA{throw}),23 the resumption throw ( \codeCFA{throwResume}) and the re-throws, were considered.22 Several other kinds of throws, beyond the termination throw (@throw@), 23 the resumption throw (@throwResume@) and the re-throws, were considered. 24 24 None were as useful as the core throws but they would likely be worth 25 25 revising. … … 114 114 is no reason not to allow it. It is however a small improvement; giving a bit 115 115 of flexibility to the user in what style they want to use. 116 \item Enabling local control flow (by \codeCFA{break}, \codeCFA{return}and116 \item Enabling local control flow (by @break@, @return@ and 117 117 similar statements) out of a termination handler. The current set-up makes 118 118 this very difficult but the catch function that runs the handler after it has -
doc/theses/andrew_beach_MMath/implement.tex
r79e261b7 rf28fdee 9 9 10 10 All of this is accessed through a field inserted at the beginning of every 11 virtual type. Currently it is called \codeC{virtual_table}but it is not11 virtual type. Currently it is called @virtual_table@ but it is not 12 12 ment to be accessed by the user. This field is a pointer to the type's 13 13 virtual table instance. It is assigned once during the object's construction … … 40 40 using that to calculate the mangled name of the parent's virtual table type. 41 41 There are two special fields that are included like normal fields but have 42 special initialization rules: the \codeC{size}field is the type's size and is43 initialized with a sizeof expression, the \codeC{align}field is the type's42 special initialization rules: the @size@ field is the type's size and is 43 initialized with a sizeof expression, the @align@ field is the type's 44 44 alignment and uses an alignof expression. The remaining fields are resolved 45 45 to a name matching the field's name and type using the normal visibility … … 56 56 The declarations include the virtual type definition and forward declarations 57 57 of the virtual table instance, constructor, message function and 58 \codeCFA{get_exception_vtable}. The definition includes the storage and58 @get_exception_vtable@. The definition includes the storage and 59 59 initialization of the virtual table instance and the bodies of the three 60 60 functions. … … 65 65 from the per-instance information. The virtual table type and most of the 66 66 functions are polymorphic so they are all part of the core. The virtual table 67 instance and the \codeCFA{get_exception_vtable}function.68 69 Coroutines and threads need instances of \codeCFA{CoroutineCancelled}and70 \codeCFA{ThreadCancelled}respectively to use all of their functionality.71 When a new data type is declared with \codeCFA{coroutine} or \codeCFA{thread}67 instance and the @get_exception_vtable@ function. 68 69 Coroutines and threads need instances of @CoroutineCancelled@ and 70 @ThreadCancelled@ respectively to use all of their functionality. 71 When a new data type is declared with @coroutine@ or @thread@ 72 72 the forward declaration for the instance is created as well. The definition 73 73 of the virtual table is created at the definition of the main function. … … 79 79 function. 80 80 81 The function is \codeC{__cfa__virtual_cast}and it is implemented in the81 The function is @__cfa__virtual_cast@ and it is implemented in the 82 82 standard library. It takes a pointer to the target type's virtual table and 83 83 the object pointer being cast. The function is very simple, getting the … … 87 87 88 88 For the generated code a forward decaration of the virtual works as follows. 89 There is a forward declaration of \codeC{__cfa__virtual_cast}in every cfa89 There is a forward declaration of @__cfa__virtual_cast@ in every cfa 90 90 file so it can just be used. The object argument is the expression being cast 91 91 so that is just placed in the argument list. … … 110 110 often across functions. 111 111 112 At a very basic level this can be done with \codeC{setjmp} \& \codeC{longjmp}112 At a very basic level this can be done with @setjmp@ \& @longjmp@ 113 113 which simply move the top of the stack, discarding everything on the stack 114 114 above a certain point. However this ignores all the clean-up code that should … … 118 118 both of these problems. 119 119 120 Libunwind, provided in \texttt{unwind.h}on most platorms, is a C library120 Libunwind, provided in @unwind.h@ on most platorms, is a C library 121 121 that provides \CPP style stack unwinding. Its operation is divided into two 122 122 phases. The search phase -- phase 1 -- is used to scan the stack and decide … … 142 142 143 143 GCC will generate an LSDA and attach its personality function with the 144 \texttt{-fexceptions}flag. However this only handles the cleanup attribute.144 @-fexceptions@ flag. However this only handles the cleanup attribute. 145 145 This attribute is used on a variable and specifies a function that should be 146 146 run when the variable goes out of scope. The function is passed a pointer to … … 165 165 messages for special cases (some of which should never be used by the 166 166 personality function) and error codes but unless otherwise noted the 167 personality function should always return \codeC{_URC_CONTINUE_UNWIND}.168 169 The \codeC{version}argument is the verson of the implementation that is167 personality function should always return @_URC_CONTINUE_UNWIND@. 168 169 The @version@ argument is the verson of the implementation that is 170 170 calling the personality function. At this point it appears to always be 1 and 171 171 it will likely stay that way until a new version of the API is updated. 172 172 173 The \codeC{action}argument is set of flags that tell the personality173 The @action@ argument is set of flags that tell the personality 174 174 function when it is being called and what it must do on this invocation. 175 175 The flags are as follows: 176 176 \begin{itemize} 177 \item \codeC{_UA_SEARCH_PHASE}: This flag is set whenever the personality177 \item@_UA_SEARCH_PHASE@: This flag is set whenever the personality 178 178 function is called during the search phase. The personality function should 179 179 decide if unwinding will stop in this function or not. If it does then the 180 personality function should return \codeC{_URC_HANDLER_FOUND}.181 \item \codeC{_UA_CLEANUP_PHASE}: This flag is set whenever the personality180 personality function should return @_URC_HANDLER_FOUND@. 181 \item@_UA_CLEANUP_PHASE@: This flag is set whenever the personality 182 182 function is called during the cleanup phase. If no other flags are set this 183 183 means the entire frame will be unwound and all cleanup code should be run. 184 \item \codeC{_UA_HANDLER_FRAME}: This flag is set during the cleanup phase184 \item@_UA_HANDLER_FRAME@: This flag is set during the cleanup phase 185 185 on the function frame that found the handler. The personality function must 186 186 prepare to return to normal code execution and return 187 \codeC{_URC_INSTALL_CONTEXT}.188 \item \codeC{_UA_FORCE_UNWIND}: This flag is set if the personality function187 @_URC_INSTALL_CONTEXT@. 188 \item@_UA_FORCE_UNWIND@: This flag is set if the personality function 189 189 is called through a forced unwind call. Forced unwind only performs the 190 190 cleanup phase and uses a different means to decide when to stop. See its … … 192 192 \end{itemize} 193 193 194 The \codeC{exception_class} argument is a copy of the \codeC{exception}'s195 \codeC{exception_class}field.196 197 The \codeC{exception}argument is a pointer to the user provided storage194 The @exception_class@ argument is a copy of the @exception@'s 195 @exception_class@ field. 196 197 The @exception@ argument is a pointer to the user provided storage 198 198 object. It has two public fields, the exception class which is actually just 199 199 a number that identifies the exception handling mechanism that created it and … … 201 201 exception needs to 202 202 203 The \codeC{context}argument is a pointer to an opaque type. This is passed203 The @context@ argument is a pointer to an opaque type. This is passed 204 204 to the many helper functions that can be called inside the personality 205 205 function. … … 218 218 functions traversing the stack new-to-old until a function finds a handler or 219 219 the end of the stack is reached. In the latter case raise exception will 220 return with \codeC{_URC_END_OF_STACK}.220 return with @_URC_END_OF_STACK@. 221 221 222 222 Once a handler has been found raise exception continues onto the the cleanup … … 227 227 228 228 If an error is encountered raise exception will return either 229 \codeC{_URC_FATAL_PHASE1_ERROR} or \codeC{_URC_FATAL_PHASE2_ERROR}depending229 @_URC_FATAL_PHASE1_ERROR@ or @_URC_FATAL_PHASE2_ERROR@ depending 230 230 on when the error occured. 231 231 … … 259 259 been unwound. 260 260 261 Each time it is called the stop function should return \codeC{_URC_NO_REASON}261 Each time it is called the stop function should return @_URC_NO_REASON@ 262 262 or transfer control directly to other code outside of libunwind. The 263 263 framework does not provide any assistance here. 264 264 265 265 Its arguments are the same as the paired personality function. 266 The actions \codeC{_UA_CLEANUP_PHASE} and \codeC{_UA_FORCE_UNWIND}are always266 The actions @_UA_CLEANUP_PHASE@ and @_UA_FORCE_UNWIND@ are always 267 267 set when it is called. By the official standard that is all but both GCC and 268 268 Clang add an extra action on the last call at the end of the stack: 269 \codeC{_UA_END_OF_STACK}.269 @_UA_END_OF_STACK@. 270 270 271 271 \section{Exception Context} … … 280 280 Each stack has its own exception context. In a purely sequental program, using 281 281 only core Cforall, there is only one stack and the context is global. However 282 if the library \texttt{libcfathread}is linked then there can be multiple282 if the library @libcfathread@ is linked then there can be multiple 283 283 stacks so they will each need their own. 284 284 285 285 To handle this code always gets the exception context from the function 286 \codeC{this_exception_context}. The main exception handling code is in287 \texttt{libcfa}and that library also defines the function as a weak symbol288 so it acts as a default. Meanwhile in \texttt{libcfathread}the function is286 @this_exception_context@. The main exception handling code is in 287 @libcfa@ and that library also defines the function as a weak symbol 288 so it acts as a default. Meanwhile in @libcfathread@ the function is 289 289 defined as a strong symbol that replaces it when the libraries are linked 290 290 together. 291 291 292 The version of the function defined in \texttt{libcfa}is very simple. It292 The version of the function defined in @libcfa@ is very simple. It 293 293 returns a pointer to a global static variable. With only one stack this 294 294 global instance is associated with the only stack. 295 295 296 The version of the function defined in \texttt{libcfathread}has to handle296 The version of the function defined in @libcfathread@ has to handle 297 297 more as there are multiple stacks. The exception context is included as 298 298 part of the per-stack data stored as part of coroutines. In the cold data 299 299 section, stored at the base of each stack, is the exception context for that 300 stack. The \codeC{this_exception_context}uses the concurrency library to get300 stack. The @this_exception_context@ uses the concurrency library to get 301 301 the current coroutine and through it the cold data section and the exception 302 302 context. … … 323 323 to store the exception. Macros with pointer arthritic and type cast are 324 324 used to move between the components or go from the embedded 325 \codeC{_Unwind_Exception}to the entire node.325 @_Unwind_Exception@ to the entire node. 326 326 327 327 All of these nodes are strung together in a linked list. One linked list per … … 347 347 C which is what the \CFA compiler outputs so a work-around is used. 348 348 349 This work around is a function called \codeC{__cfaehm_try_terminate}in the349 This work around is a function called @__cfaehm_try_terminate@ in the 350 350 standard library. The contents of a try block and the termination handlers 351 351 are converted into functions. These are then passed to the try terminate … … 385 385 386 386 These nested functions and all other functions besides 387 \codeC{__cfaehm_try_terminate}in \CFA use the GCC personality function and388 the \texttt{-fexceptions}flag to generate the LSDA. This allows destructors387 @__cfaehm_try_terminate@ in \CFA use the GCC personality function and 388 the @-fexceptions@ flag to generate the LSDA. This allows destructors 389 389 to be implemented with the cleanup attribute. 390 390 … … 401 401 402 402 The handler function does both the matching and catching. It tries each 403 the condition of \codeCFA{catchResume}in order, top-to-bottom and until it403 the condition of @catchResume@ in order, top-to-bottom and until it 404 404 finds a handler that matches. If no handler matches then the function returns 405 405 false. Otherwise the matching handler is run, if it completes successfully 406 the function returns true. Rethrows, through the \codeCFA{throwResume;}406 the function returns true. Rethrows, through the @throwResume;@ 407 407 statement, cause the function to return true. 408 408 … … 438 438 439 439 Cancellation also uses libunwind to do its stack traversal and unwinding, 440 however it uses a different primary function \codeC{_Unwind_ForcedUnwind}.440 however it uses a different primary function @_Unwind_ForcedUnwind@. 441 441 Details of its interface can be found in the unwind section. 442 442 -
doc/theses/andrew_beach_MMath/unwinding.tex
r79e261b7 rf28fdee 10 10 Even this is fairly simple if nothing needs to happen when the stack unwinds. 11 11 Traditional C can unwind the stack by saving and restoring state (with 12 \codeC{setjmp} \& \codeC{longjmp}). However many languages define actions that12 @setjmp@ \& @longjmp@). However many languages define actions that 13 13 have to be taken when something is removed from the stack, such as running 14 a variable's destructor or a \codeCFA{try} statement's \codeCFA{finally}14 a variable's destructor or a @try@ statement's @finally@ 15 15 clause. Handling this requires walking the stack going through each stack 16 16 frame. … … 29 29 30 30 \CFA uses two primary functions in libunwind to create most of its 31 exceptional control-flow: \codeC{_Unwind_RaiseException}and32 \codeC{_Unwind_ForcedUnwind}.31 exceptional control-flow: @_Unwind_RaiseException@ and 32 @_Unwind_ForcedUnwind@. 33 33 Their operation is divided into two phases: search and clean-up. The search 34 34 phase -- phase 1 -- is used to scan the stack but not unwinding it. The … … 44 44 A personality function performs three tasks, although not all have to be 45 45 present. The tasks performed are decided by the actions provided. 46 \codeC{_Unwind_Action}is a bitmask of possible actions and an argument of46 @_Unwind_Action@ is a bitmask of possible actions and an argument of 47 47 this type is passed into the personality function. 48 48 \begin{itemize} 49 \item \codeC{_UA_SEARCH_PHASE}is passed in search phase and tells the49 \item@_UA_SEARCH_PHASE@ is passed in search phase and tells the 50 50 personality function to check for handlers. If there is a handler in this 51 51 stack frame, as defined by the language, the personality function should 52 return \codeC{_URC_HANDLER_FOUND}. Otherwise it should return53 \codeC{_URC_CONTINUE_UNWIND}.54 \item \codeC{_UA_CLEANUP_PHASE}is passed in during the clean-up phase and52 return @_URC_HANDLER_FOUND@. Otherwise it should return 53 @_URC_CONTINUE_UNWIND@. 54 \item@_UA_CLEANUP_PHASE@ is passed in during the clean-up phase and 55 55 means part or all of the stack frame is removed. The personality function 56 56 should do whatever clean-up the language defines 57 57 (such as running destructors/finalizers) and then generally returns 58 \codeC{_URC_CONTINUE_UNWIND}.59 \item \codeC{_UA_HANDLER_FRAME}means the personality function must install58 @_URC_CONTINUE_UNWIND@. 59 \item@_UA_HANDLER_FRAME@ means the personality function must install 60 60 a handler. It is also passed in during the clean-up phase and is in addition 61 61 to the clean-up action. libunwind provides several helpers for the personality 62 62 function here. Once it is done, the personality function must return 63 \codeC{_URC_INSTALL_CONTEXT}.63 @_URC_INSTALL_CONTEXT@. 64 64 \end{itemize} 65 65 The personality function is given a number of other arguments. Some are for 66 compatability and there is the \codeC{struct _Unwind_Context}pointer which66 compatability and there is the @struct _Unwind_Context@ pointer which 67 67 passed to many helpers to get information about the current stack frame. 68 68 … … 72 72 raise-exception but with some extras. 73 73 The first it passes in an extra action to the personality function on each 74 stack frame, \codeC{_UA_FORCE_UNWIND}, which means a handler cannot be74 stack frame, @_UA_FORCE_UNWIND@, which means a handler cannot be 75 75 installed. 76 76 … … 83 83 stack frames have been removed. By the standard API this is marked by setting 84 84 the stack pointer inside the context passed to the stop function. However both 85 GCC and Clang add an extra action for this case \codeC{_UA_END_OF_STACK}.85 GCC and Clang add an extra action for this case @_UA_END_OF_STACK@. 86 86 87 87 Each time function the stop function is called it can do one or two things. 88 When it is not the end of the stack it can return \codeC{_URC_NO_REASON}to88 When it is not the end of the stack it can return @_URC_NO_REASON@ to 89 89 continue unwinding. 90 90 % Is there a reason that NO_REASON is used instead of CONTINUE_UNWIND? … … 113 113 114 114 The stop function is very simple. It checks the end of stack flag to see if 115 it is finished unwinding. If so, it calls \codeC{exit}to end the process,115 it is finished unwinding. If so, it calls @exit@ to end the process, 116 116 otherwise it returns with no-reason to continue unwinding. 117 117 % Yeah, this is going to have to change. … … 128 128 location of the instruction pointer and stack layout, which varies with 129 129 compiler and optimization levels. So for frames where there are only 130 destructors, GCC's attribute cleanup with the \texttt{-fexception}flag is130 destructors, GCC's attribute cleanup with the @-fexception@ flag is 131 131 sufficient to handle unwinding. 132 132 133 133 The only functions that require more than that are those that contain 134 \codeCFA{try} statements. A \codeCFA{try} statement has a \codeCFA{try} 135 clause, some number of \codeCFA{catch} clauses and \codeCFA{catchResume}136 clauses and may have a \codeCFA{finally} clause. Of these only \codeCFA{try}137 statements with \codeCFA{catch}clauses need to be transformed and only they138 and the \codeCFA{try}clause are involved.134 @try@ statements. A @try@ statement has a @try@ 135 clause, some number of @catch@ clauses and @catchResume@ 136 clauses and may have a @finally@ clause. Of these only @try@ 137 statements with @catch@ clauses need to be transformed and only they 138 and the @try@ clause are involved. 139 139 140 The \codeCFA{try}statement is converted into a series of closures which can140 The @try@ statement is converted into a series of closures which can 141 141 access other parts of the function according to scoping rules but can be 142 passed around. The \codeCFA{try}clause is converted into the try functions,143 almost entirely unchanged. The \codeCFA{catch}clauses are converted into two142 passed around. The @try@ clause is converted into the try functions, 143 almost entirely unchanged. The @catch@ clauses are converted into two 144 144 functions; the match function and the catch function. 145 145 … … 153 153 runs the handler's body. 154 154 155 These three functions are passed to \codeC{try_terminate}. This is an155 These three functions are passed to @try_terminate@. This is an 156 156 % Maybe I shouldn't quote that, it isn't its actual name. 157 157 internal hand-written function that has its own personality function and … … 167 167 handler was found in this frame. If it was then the personality function 168 168 installs the handler, which is setting the instruction pointer in 169 \codeC{try_terminate}to an otherwise unused section that calls the catch169 @try_terminate@ to an otherwise unused section that calls the catch 170 170 function, passing it the current exception and handler index. 171 \codeC{try_terminate}returns as soon as the catch function returns.171 @try_terminate@ returns as soon as the catch function returns. 172 172 173 173 At this point control has returned to normal control flow.
Note: See TracChangeset
for help on using the changeset viewer.
