Changeset c21f5a9 for doc/theses

Timestamp:

May 20, 2021, 10:53:21 AM (3 years ago)

Author:

Andrew Beach <ajbeach@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

090a7c5

Parents:

77f1265

Message:

Andrew MMath: Work on figures and linkonce.

Location:

doc/theses/andrew_beach_MMath

Files:

• cfalab.sty (modified) (1 diff)
• features.tex (modified) (1 diff)
• implement.tex (modified) (7 diffs)

doc/theses/andrew_beach_MMath/cfalab.sty

@@ -40 +40 @@
       \def\Cpp{C++}
       \def\lstinline{}
+      \def\code#1#2{#2}
     }
   }{}

doc/theses/andrew_beach_MMath/features.tex

@@ -150 +150 @@
 It is important to note that these are virtual members, not virtual methods
 of object-orientated programming, and can be of any type.
-However, since \CFA has function pointers and they are allowed, virtual
-members can be used to mimic virtual methods.
+\CFA still supports virtual methods as a special case of virtual members.
+Function pointers that take a pointer to the virtual type will be modified
+with each level of inheritance so that refers to the new type.
+This means an object can always be passed to a function in its virtual table
+as if it were a method.
 
 Each virtual type has a unique id.

doc/theses/andrew_beach_MMath/implement.tex

@@ -71 +71 @@
 
 \begin{cfa}
-struct /* type name */ {
-        /* parent type name */ const * parent;
+struct TYPE_ID_TYPE {
+        PARENT_ID_TYPE const * parent;
 };
 
-__attribute__((section(".gnu.linkonce./* instance name */")))
-/* type name */ const /* instance name */ = {
-        &/* parent instance name */,
+__attribute__((cfa_linkonce))
+TYPE_ID_TYPE const TYPE_ID_NAME = {
+        &PARENT_ID_NAME,
 };
 \end{cfa}
+
+\subsubsection{cfa\_linkonce Attribute}
+Another feature added to \CFA is a new attribute: \texttt{cfa\_linkonce}.
+This attribute can be put on an object or function definition
+(any global declaration with a name and a type).
+This allows you to define that object or function multiple times.
+All definitions should have the link-once attribute on them and all should
+be identical.
+
+The simplist way to use it is to put a definition in a header where the
+forward declaration would usually go.
+This is how it is used for type-id instances. There was is no unique location
+associated with a type except for the type definition which is in a header.
+This allows the unique type-id object to be generated there.
+
+Internally @cfa_linkonce@ removes all @section@ attributes
+from the declaration (as well as itself) and replaces them with
+@section(".gnu.linkonce.NAME")@ where \texttt{NAME} is replaced by the
+mangled name of the object.
+The prefix \texttt{.gnu.linkonce} in section names is recognized by the
+linker. If two of these sections with the same name, including everything
+that comes after the special prefix, then only one will be used and the other
+will be discarded.
 
 \subsection{Virtual Table}
@@ -124 +147 @@
 underlying object, access any of the virtual members and pass the object to
 any of the method-like virtual members.
-\todo{Introduce method-like virtual members.}
 
 When a virtual table is declared the user decides where to declare it and its
@@ -144 +166 @@
 the instance is created as well. The definition of the virtual table is created
 at the definition of the main function.
-\todo{Add an example with code snipits.}
+
+\begin{figure}
+\begin{cfa}
+coroutine Example {
+        // fields
+}
+\end{cfa}
+
+\begin{cfa}
+__attribute__((cfa_linkonce))
+struct __cfatid_struct_CoroutineCancelled(Example)
+                __cfatid_CoroutineCancelled = {
+        &EXCEPTION_TYPE_ID,
+};
+extern CoroutineCancelled_vtable _default_vtable_object_declaration;
+extern CoroutineCancelled_vtable & _default_vtable;
+\end{cfa}
+
+\begin{cfa}
+void main(Example & this) {
+        // body
+}
+\end{cfa}
+
+\begin{cfa}
+CoroutineCancelled_vtable _default_vtable_object_declaration = {
+        __cfatid_CoroutineCancelled,
+        // Virtual member initialization.
+};
+
+CoroutineCancelled_vtable & _default_vtable =
+        &_default_vtable_object_declaration;
+\end{cfa}
+\caption{Concurrency Transformations}
+\label{f:ConcurrencyTransformations}
+\end{figure}
+\todo{Improve Concurrency Transformations figure.}
 
 \subsection{Virtual Cast}
@@ -155 +213 @@
 \begin{cfa}
 void * __cfa__virtual_cast(
-        struct __cfa__parent_vtable const * parent,
-        struct __cfa__parent_vtable const * const * child );
-\end{cfa}
-\todo{Get rid of \_\_cfa\_\_parent\_vtable in the standard library and then
-the document.}
+        struct __cfavir_type_td parent,
+        struct __cfavir_type_id const * child );
+\end{cfa}
 The type id of target type of the virtual cast is passed in as @parent@ and
 the cast target is passed in as @child@.
@@ -572 +628 @@
 the LSDA.
 Using this pattern, \CFA implements destructors with the cleanup attribute.
-\todo{Add an example of the conversion from try statement to functions.}
+
+\begin{figure}
+\begin{cfa}
+try {
+        // TRY BLOCK
+} catch (Exception1 * name1 ; check(name1)) {
+        // CATCH BLOCK 1
+} catch (Exception2 * name2) {
+        // CATCH BLOCK 2
+}
+\end{cfa}
+
+\begin{cfa}
+void try(void) {
+        // TRY BLOCK
+}
+int match(exception_t * __exception_inst) {
+        {
+                Exception1 * name1;
+                if (name1 = (virtual Exception1 *)__exception_inst && check(name1)) {
+                        return 1;
+                }
+        }
+        {
+                Exception2 * name2;
+                if (name2 = (virtual Exception2 *)__exception_inst) {
+                        return 2;
+                }
+        }
+        return 0;
+}
+void catch(exception_t * __exception_inst, int __handler_index) {
+        switch (__handler_index) {
+        case 1:
+        {
+                Exception1 * name1 = (virtual Exception1 *)__exception_inst;
+                // CATCH BLOCK 1
+        }
+        return;
+        case 2:
+        {
+                Exception2 * name2 = (virtual Exception2 *)__exception_inst;
+                // CATCH BLOCK 2
+        }
+        return;
+        }
+}
+{
+        __cfaehm_try_terminate(try, catch, match);
+}
+\end{cfa}
+
+\caption{Termination Transformation}
+\label{f:TerminationTransformation}
+\todo*{Improve (compress?) Termination Transformations.}
+\end{figure}
 
 \section{Resumption}
@@ -606 +717 @@
 the next clause the function returns false as no handler could be found.
 
-\todo{Diagram showing a try statement being converted into resumption handlers.}
+\begin{figure}
+\begin{cfa}
+try {
+        // TRY BLOCK
+} catchResume (Exception1 * name1 ; check(name1)) {
+        // CATCH BLOCK 1
+} catchResume (Exception2 * name2) {
+        // CATCH BLOCK 2
+}
+\end{cfa}
+
+\begin{cfa}
+bool handle(exception_t * __exception_inst) {
+        {
+                Exception1 * name1;
+                if (name1 = (virtual Exception1 *)__exception_inst && check(name1)) {
+                        // CATCH BLOCK 1
+                        return 1;
+                }
+        }
+        {
+                Exception2 * name2;
+                if (name2 = (virtual Exception2 *)__exception_inst) {
+                        // CATCH BLOCK 2
+                        return 2;
+                }
+        }
+        return false;
+}
+struct __try_resume_node __resume_node
+        __attribute__((cleanup( __cfaehm_try_resume_cleanup )));
+__cfaehm_try_resume_setup( &__resume_node, handler );
+\end{cfa}
+
+\caption{Resumption Transformation}
+\label{f:ResumptionTransformation}
+\todo*{Improve (compress?) Resumption Transformations.}
+\end{figure}
 
 % Recursive Resumption Stuff:
@@ -625 +773 @@
 stack -- the first one points over all the checked handlers -- and the ordering
 is maintained.
-\todo{Add a diagram for resumption marking.}
+
+\begin{figure}
+\begin{minipage}[l][][b]{0,2\textwidth}
+\begin{verbatim}
+
+
+  X <-
+  |
+  V
+  X
+  |
+  V
+  X
+\end{verbatim}
+Initial State
+\end{minipage}
+\begin{minipage}[l][][b]{0,2\textwidth}
+\begin{verbatim}
+
+
+  X
+  |
+  V
+  X <-
+  |
+  V
+  X
+\end{verbatim}
+Handler Found
+\end{minipage}
+\begin{minipage}[l][][b]{0,2\textwidth}
+\begin{verbatim}
+  X <-
+ /
+/ X
+| |
+\ V
+  X
+  |
+  V
+  X
+\end{verbatim}
+Try Block Added
+\end{minipage}
+\begin{minipage}[l][][b]{0,2\textwidth}
+\begin{verbatim}
+
+
+  X <-
+  |
+  V
+  X
+  |
+  V
+  X
+\end{verbatim}
+Handler Done
+\end{minipage}
+\caption{Resumption Marking}
+\label{f:ResumptionMarking}
+\todo*{Convert Resumption Marking into a line figure.}
+\end{figure}
 
 \label{p:zero-cost}