Changeset 1ed33fed

Jenkinsfile

r6ac2ada	r1ed33fed
274	274	//Run the tests from the tests directory
275	275	if ( do_alltests ) {
276		sh 'make -C src/tests all-tests debug=yes'
277		sh 'make -C src/tests all-tests debug=no'
	276	sh 'make -C src/tests all-tests debug=yes --no-print-directory'
	277	sh 'make -C src/tests all-tests debug=no --no-print-directory'
278	278	}
279	279	else {
280		sh 'make -C src/tests'
	280	sh 'make -C src/tests --no-print-directory'
281	281	}
282	282	}

doc/LaTeXmacros/common.tex

-              r6ac2ada
+              r1ed33fed
 \lstdefinelanguage{CFA}[ANSI]{C}{
         morekeywords={_Alignas,_Alignof,__alignof,__alignof__,asm,__asm,__asm__,_At,_Atomic,__attribute,__attribute__,auto,
                 _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,disable,dtype,enable,__extension__,
                 fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,_Noreturn,one_t,otype,restrict,_Static_assert,
                 _Thread_local,throw,throwResume,trait,try,ttype,typeof,__typeof,__typeof__,zero_t},
+                _Bool,catch,catchResume,choose,_Complex,__complex,__complex__,__const,__const__,coroutine,disable,dtype,enable,__extension__,
+                fallthrough,fallthru,finally,forall,ftype,_Generic,_Imaginary,inline,__label__,lvalue,monitor,mutex,_Noreturn,one_t,otype,restrict,_Static_assert,
+                thread,_Thread_local,throw,throwResume,trait,try,ttype,typeof,__typeof,__typeof__,zero_t},
 }%

doc/proposals/concurrency/Makefile

r6ac2ada	r1ed33fed
10	10	concurrency \
11	11	style \
	12	cfa-format \
12	13	glossary \
13	14	}

doc/proposals/concurrency/concurrency.tex

-              r6ac2ada
+              r1ed33fed
 % math escape $...$ (dollar symbol)
 \documentclass[twoside,11pt]{article}
+\documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \usepackage{graphicx}
 \usepackage{tabularx}
+\usepackage{multicol}
 \usepackage[acronym]{glossaries}
+\usepackage{varioref}                                           % extended references
+\usepackage{inconsolata}
+\usepackage{varioref}
 \usepackage{listings}                                           % format program code
 \usepackage[flushmargin]{footmisc}                              % support label/reference in footnote
 …
 \newcommand{\cit}{\textsuperscript{[Citation Needed]}\xspace}
 \newcommand{\code}[1]{\lstinline[language=CFA]{#1}}
+\newcommand{\pseudo}[1]{\lstinline[language=Pseudo]{#1}}
+\newcommand{\pscode}[1]{\lstinline[language=pseudo]{#1}}
+\newcommand{\TODO}{{\Textbf{TODO}}}
 \input{glossary}
 …
 % ### #     #    #    #     # #######
 \section{Introduction}
+\chapter{Introduction}
 This proposal provides a minimal core concurrency API that is both simple, efficient and can be reused to build higher-level features. The simplest possible concurrency core is a thread and a lock but this low-level approach is hard to master. An easier approach for users is to support higher-level constructs as the basis of the concurrency in \CFA. Indeed, for highly productive parallel programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading.
 …
 %  #####  ####### #     #  #####   #####  #     # #     # ####### #     #  #####     #
 \section{Concurrency}
+\chapter{Concurrency}
 Several tool can be used to solve concurrency challenges. Since these challenges always appear with the use of mutable shared-state, some languages and libraries simply disallow mutable shared-state (Erlang~\cite{Erlang}, Haskell~\cite{Haskell}, Akka (Scala)~\cite{Akka}). In these paradigms, interaction among concurrent objects relies on message passing~\cite{Thoth,Harmony,V-Kernel} or other paradigms that closely relate to networking concepts (channels\cit for example). However, in languages that use routine calls as their core abstraction mechanism, these approaches force a clear distinction between concurrent and non-concurrent paradigms (i.e., message passing versus routine call). Which in turn means that, in order to be effective, programmers need to learn two sets of designs patterns. This distinction can be hidden away in library code, but effective use of the librairy still has to take both paradigms into account. Approaches based on shared memory are more closely related to non-concurrent paradigms since they often rely on basic constructs like routine calls and objects. At a lower level these can be implemented as locks and atomic operations. Many such mechanisms have been proposed, including semaphores~\cite{Dijkstra68b} and path expressions~\cite{Campbell74}. However, for productivity reasons it is desireable to have a higher-level construct be the core concurrency paradigm~\cite{HPP:Study}. An approach that is worth mentionning because it is gaining in popularity is transactionnal memory~\cite{Dice10}[Check citation]. While this approach is even pursued by system languages like \CC\cit, the performance and feature set is currently too restrictive to add such a paradigm to a language like C or \CC\cit, which is why it was rejected as the core paradigm for concurrency in \CFA. One of the most natural, elegant, and efficient mechanisms for synchronization and communication, especially for shared memory systems, is the \emph{monitor}. Monitors were first proposed by Brinch Hansen~\cite{Hansen73} and later described and extended by C.A.R.~Hoare~\cite{Hoare74}. Many programming languages---e.g., Concurrent Pascal~\cite{ConcurrentPascal}, Mesa~\cite{Mesa}, Modula~\cite{Modula-2}, Turing~\cite{Turing:old}, Modula-3~\cite{Modula-3}, NeWS~\cite{NeWS}, Emerald~\cite{Emerald}, \uC~\cite{Buhr92a} and Java~\cite{Java}---provide monitors as explicit language constructs. In addition, operating-system kernels and device drivers have a monitor-like structure, although they often use lower-level primitives such as semaphores or locks to simulate monitors. For these reasons, this project proposes monitors as the core concurrency construct.
 …
 % #     # ####### #     # ###    #    ####### #     #  #####
 \subsection{Monitors}
+\section{Monitors}
 A monitor is a set of routines that ensure mutual exclusion when accessing shared state. This concept is generally associated with Object-Oriented Languages like Java~\cite{Java} or \uC~\cite{uC++book} but does not strictly require OOP semantics. The only requirements is the ability to declare a handle to a shared object and a set of routines that act on it :
 \begin{lstlisting}
+\begin{cfacode}
         typedef /*some monitor type*/ monitor;
         int f(monitor & m);
 …
                 f(m);
+        }
 \end{lstlisting}
+\end{cfacode}
 %  #####     #    #       #
 …
 %  #####  #     # ####### #######
 \subsubsection{Call semantics} \label{call}
+\subsection{Call semantics} \label{call}
 The above monitor example displays some of the intrinsic characteristics. Indeed, it is necessary to use pass-by-reference over pass-by-value for monitor routines. This semantics is important because at their core, monitors are implicit mutual-exclusion objects (locks), and these objects cannot be copied. Therefore, monitors are implicitly non-copyable.
 Another aspect to consider is when a monitor acquires its mutual exclusion. For example, a monitor may need to be passed through multiple helper routines that do not acquire the monitor mutual-exclusion on entry. Pass through can be both generic helper routines (\code{swap}, \code{sort}, etc.) or specific helper routines like the following to implement an atomic counter :
 \begin{lstlisting}
         mutex struct counter_t { /*...see section §\ref{data}§...*/ };
+\begin{cfacode}
+        monitor counter_t { /*...see section $\ref{data}$...*/ };
         void ?{}(counter_t & nomutex this); //constructor
 …
         //need for mutex is platform dependent here
         void ?{}(size_t * this, counter_t & mutex cnt); //conversion
 \end{lstlisting}
+\end{cfacode}
 Here, the constructor(\code{?\{\}}) uses the \code{nomutex} keyword to signify that it does not acquire the monitor mutual exclusion when constructing. This semantics is because an object not yet constructed should never be shared and therefore does not require mutual exclusion. The prefix increment operator uses \code{mutex} to protect the incrementing process from race conditions. Finally, there is a conversion operator from \code{counter_t} to \code{size_t}. This conversion may or may not require the \code{mutex} key word depending on whether or not reading an \code{size_t} is an atomic operation or not.
+Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without quualifiers \code{void foo(counter_t & this)} then one could argue that it should default to the safest option \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that \code{nomutex} is the more "normal" behaviour, the \code{nomutex} keyword effectively stating explicitly that "this routine has nothing special". Another alternative is to make having exactly one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being self-documented but at the cost of extra typing. In the end, which solution should be picked is still up for debate. For the reminder of this proposal, the explicit approach is used for clarity.
+The next semantic decision is to establish when mutex/nomutex may be used as a type qualifier. Consider the following declarations:
+\begin{lstlisting}
+Having both \code{mutex} and \code{nomutex} keywords could be argued to be redundant based on the meaning of a routine having neither of these keywords. For example, given a routine without quualifiers \code{void foo(counter_t & this)} then one could argue that it should default to the safest option \code{mutex}. On the other hand, the option of having routine \code{void foo(counter_t & this)} mean \code{nomutex} is unsafe by default and may easily cause subtle errors. It can be argued that \code{nomutex} is the more "normal" behaviour, the \code{nomutex} keyword effectively stating explicitly that "this routine has nothing special". Another alternative is to make having exactly one of these keywords mandatory, which would provide the same semantics but without the ambiguity of supporting routine \code{void foo(counter_t & this)}. Mandatory keywords would also have the added benefice of being self-documented but at the cost of extra typing. However, since \CFA relies heavily on traits as an abstraction mechanism, the distinction between a type that is a monitor and a type that looks like a monitor can become blurred. For this reason, \CFA only has the \code{mutex} keyword.
+The next semantic decision is to establish when \code{mutex} may be used as a type qualifier. Consider the following declarations:
+\begin{cfacode}
         int f1(monitor & mutex m);
         int f2(const monitor & mutex m);
 …
         int f4(monitor *[] mutex m);
         int f5(graph(monitor*) & mutex m);
+\end{lstlisting}
+The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter (ignoring potential qualifiers and indirections). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. However, this ambiguity is part of the C type system with respects to arrays. For this reason, it would also be reasonnable to disallow mutex in the context where arrays may be passed.
+\end{cfacode}
+The problem is to indentify which object(s) should be acquired. Furthermore, each object needs to be acquired only once. In the case of simple routines like \code{f1} and \code{f2} it is easy to identify an exhaustive list of objects to acquire on entry. Adding indirections (\code{f3}) still allows the compiler and programmer to indentify which object is acquired. However, adding in arrays (\code{f4}) makes it much harder. Array lengths are not necessarily known in C and even then making sure we only acquire objects once becomes also none trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To keep everyone as sane as possible~\cite{Chicken}, this projects imposes the requirement that a routine may only acquire one monitor per parameter and it must be the type of the parameter with one level of indirection (ignoring potential qualifiers). Also note that while routine \code{f3} can be supported, meaning that monitor \code{**m} is be acquired, passing an array to this routine would be type safe and yet result in undefined behavior because only the first element of the array is acquired. However, this ambiguity is part of the C type system with respects to arrays. For this reason, \code{mutex} is disallowed in the context where arrays may be passed.
+Finally, for convenience, monitors support multiple acquireing, that is acquireing a monitor while already holding it does not cause a deadlock. It simply increments an internal counter which is then used to release the monitor after the number of acquires and releases match up.
 % ######     #    #######    #
 …
 % ######  #     #    #    #     #
 \subsubsection{Data semantics} \label{data}
+\subsection{Data semantics} \label{data}
 Once the call semantics are established, the next step is to establish data semantics. Indeed, until now a monitor is used simply as a generic handle but in most cases monitors contian shared data. This data should be intrinsic to the monitor declaration to prevent any accidental use of data without its appropriate protection. For example, here is a complete version of the counter showed in section \ref{call}:
 \begin{lstlisting}
         mutex struct counter_t {
+\begin{cfacode}
+        monitor counter_t {
                 int value;
         };
         void ?{}(counter_t & nomutex this) {
+        void ?{}(counter_t & this) {
                 this.cnt = 0;
+        }
 …
                 *this = (int)cnt;
+        }
 \end{lstlisting}
+\end{cfacode}
 This simple counter is used as follows:
 \begin{center}
 \begin{tabular}{c @{\hskip 0.35in} c @{\hskip 0.35in} c}
 \begin{lstlisting}
+\begin{cfacode}
         //shared counter
         counter_t cnt;
 …
           ...
         thread N : cnt++;
 \end{lstlisting}
+\end{cfacode}
 \end{tabular}
 \end{center}
 Notice how the counter is used without any explicit synchronisation and yet supports thread-safe semantics for both reading and writting. Unlike object-oriented monitors, where calling a mutex member \emph{implicitly} acquires mutual-exclusion, \CFA uses an explicit mechanism to acquire mutual-exclusion. A consequence of this approach is that it extends to multi-monitor calls.
 \begin{lstlisting}
+\begin{cfacode}
         int f(MonitorA & mutex a, MonitorB & mutex b);
 …
         MonitorB b;
         f(a,b);
 \end{lstlisting}
+\end{cfacode}
 This code acquires both locks before entering the critical section, called \emph{\gls{group-acquire}}. In practice, writing multi-locking routines that do not lead to deadlocks is tricky. Having language support for such a feature is therefore a significant asset for \CFA. In the case presented above, \CFA guarantees that the order of aquisition is consistent across calls to routines using the same monitors as arguments. However, since \CFA monitors use multi-acquisition locks, users can effectively force the acquiring order. For example, notice which routines use \code{mutex}/\code{nomutex} and how this affects aquiring order :
 \begin{lstlisting}
+\begin{cfacode}
         void foo(A & mutex a, B & mutex b) { //acquire a & b
                 //...
+        }
         void bar(A & mutex a, B & nomutex b) { //acquire a
+        void bar(A & mutex a, B & /*nomutex*/ b) { //acquire a
                 //...
                 foo(a, b); //acquire b
 …
+        }
         void baz(A & nomutex a, B & mutex b) { //acquire b
+        void baz(A & /*nomutex*/ a, B & mutex b) { //acquire b
                 //...
                 foo(a, b); //acquire a
                 //...
+        }
 \end{lstlisting}
 The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order. such use leads to nested monitor call problems~\cite{Lister77}, which is a specific implementation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires :
+\end{cfacode}
+The multi-acquisition monitor lock allows a monitor lock to be acquired by both \code{bar} or \code{baz} and acquired again in \code{foo}. In the calls to \code{bar} and \code{baz} the monitors are acquired in opposite order. such use leads to nested monitor call problems~\cite{Lister77}, which is a more specific variation of the lock acquiring order problem. In the example above, the user uses implicit ordering in the case of function \code{foo} but explicit ordering in the case of \code{bar} and \code{baz}. This subtle mistake means that calling these routines concurrently may lead to deadlock and is therefore undefined behavior. As shown on several occasion\cit, solving this problem requires :
 \begin{enumerate}
         \item Dynamically tracking of the monitor-call order.
 …
 %             #       ####### #######    #    #     # ####### #     # #     #
 \subsubsection{Implementation Details: Interaction with polymorphism}
+\subsection{Implementation Details: Interaction with polymorphism}
 At first glance, interaction between monitors and \CFA's concept of polymorphism seems complex to support. However, it is shown that entry-point locking can solve most of the issues.
 …
 \CFA & pseudo-code & pseudo-code \\
 \hline
 \begin{lstlisting}
 void foo(monitor & mutex a) {
+\begin{cfacode}[tabsize=3]
+void foo(monitor& mutex a){
 …
+}
 \end{lstlisting} &\begin{lstlisting}
+\end{cfacode} & \begin{pseudo}[tabsize=3]
 foo(& a) {
 …
         release(a);
+}
 \end{lstlisting} &\begin{lstlisting}
+\end{pseudo} & \begin{pseudo}[tabsize=3]
 foo(& a) {
         //called routine
 …
+}
 \end{lstlisting}
+\end{pseudo}
 \end{tabular}
 \end{center}
+First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. \Gls{callsite-locking} would require a significant amount of work, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else.
+First of all, interaction between \code{otype} polymorphism and monitors is impossible since monitors do not support copying. Therefore, the main question is how to support \code{dtype} polymorphism. Since a monitor's main purpose is to ensure mutual exclusion when accessing shared data, this implies that mutual exclusion is only required for routines that do in fact access shared data. However, since \code{dtype} polymorphism always handles incomplete types (by definition), no \code{dtype} polymorphic routine can access shared data since the data requires knowledge about the type. Therefore, the only concern when combining \code{dtype} polymorphism and monitors is to protect access to routines. \Gls{callsite-locking} would require a significant amount of work, since any \code{dtype} routine may have to obtain some lock before calling a routine, depending on whether or not the type passed is a monitor. However, with \gls{entry-point-locking} calling a monitor routine becomes exactly the same as calling it from anywhere else. Note that the \code{mutex} keyword relies on the resolver, which mean that in cases where generic monitor routines is actually desired, writing mutex routine is possible with the proper trait.
 …
 % ### #     #    #    ###     #####   #####  #     # ####### ######
+\subsection{Internal scheduling} \label{insched}
+\begin{center}
+\begin{tabular}{ c @{\hskip 0.65in} c }
+\begin{lstlisting}[language=Pseudo]
+\section{Internal scheduling} \label{insched}
+In addition to mutual exclusion, the monitors at the core of \CFA's concurrency can also be used to achieve synchronisation. With monitors, this is generally achieved with internal or external scheduling as in\cit. Since internal scheduling of single monitors is mostly a solved problem, this proposal concentraits on extending internal scheduling to multiple monitors at once. Indeed, like the \gls{group-acquire} semantics, internal scheduling extends to multiple monitors at once in a way that is natural to the user but requires additional complexity on the implementation side.
+First, Here is a simple example of such a technique :
+\begin{cfacode}
+        monitor A {
+                condition e;
+        }
+        void foo(A & mutex a) {
+                // ...
+                // We need someone else to do something now
+                wait(a.e);
+                // ...
+        }
+        void bar(A & mutex a) {
+                // Do the thing foo is waiting on
+                // ...
+                // Signal foo it's done
+                signal(a.e);
+        }
+\end{cfacode}
+Note that in \CFA, \code{condition} have no particular need to be stored inside a monitor, beyond any software engineering reasons. Here routine \code{foo} waits for the \code{signal} from \code{bar} before making further progress, effectively ensuring a basic ordering. An important aspect to take into account here is that \CFA does not allow barging, which means that once function \code{bar} releases the monitor, foo is guaranteed to resume immediately after (unless some other function waited on the same condition). This guarantees offers the benefit of not having to loop arount waits in order to guarantee that a condition is still met. The main reason \CFA offers this guarantee is that users can easily introduce barging if it becomes a necessity but adding a barging prevention or barging avoidance is more involved without language support.
+Supporting barging prevention as well as extending internal scheduling to multiple monitors is the main source of complexity in the design of \CFA concurrency.
+\subsection{Internal Scheduling - multi monitor}
+It easier to understand the problem of multi monitor scheduling using a series of pseudo code though experiment. Note that in the following snippets of pseudo-code waiting and signalling is done without the use of a condition variable. While \CFA requires condition variables to use signalling, the variable itself only really holds the data needed for the implementation of internal schedulling. Some languages like JAVA\cit simply define an implicit condition variable for every monitor while other languages like \uC use explicit condition variables. Since the following pseudo-codes are simple and focused experiments, all condition variables are implicit.
+\begin{multicols}{2}
+\begin{pseudo}
 acquire A
         wait A
 release A
+\end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+\end{pseudo}
+\columnbreak
+\begin{pseudo}
 acquire A
         signal A
 release A
+\end{lstlisting}
+\end{tabular}
+\end{center}
+Easy : like uC++
+\begin{center}
+\begin{tabular}{ c @{\hskip 0.65in} c }
+\begin{lstlisting}[language=Pseudo]
+\end{pseudo}
+\end{multicols}
+The previous example shows the simple case of having two threads (one for each column) and a single monitor A. One thread acquires before waiting and the other acquires before signalling. There are a few important things to note here. First, both \code{wait} and \code{signal} must be called with the proper monitor(s) already acquired. This can be hidden on the user side but is a logical requirement for barging prevention. Secondly, as stated above, while it is argued that not all problems regarding single monitors are solved, this paper only regards challenges of \gls{group-acquire} and considers other problems related to monitors as solved.
+An important note about this example is that signalling a monitor is a delayed operation. The ownership of the monitor is transferred only when the monitor would have otherwise been released, not at the point of the \code{signal} statement.
+A direct extension of the previous example is the \gls{group-acquire} version :
+\begin{multicols}{2}
+\begin{pseudo}
+acquire A & B
+        wait A & B
+release A & B
+\end{pseudo}
+\columnbreak
+\begin{pseudo}
+acquire A & B
+        signal A & B
+release A & B
+\end{pseudo}
+\end{multicols}
+This version uses \gls{group-acquire} (denoted using the \& symbol), but the presence of multiple monitors does not add a particularly new meaning. Synchronization will happen between the two threads in exactly the same way and order. The only difference is that mutual exclusion will cover more monitors. On the implementation side, handling multiple monitors at once does add a degree of complexity but it is not significant compared to the next few examples.
+For the sake of completeness, here is another example of the single-monitor case, this time with nesting.
+\begin{multicols}{2}
+\begin{pseudo}
 acquire A
         acquire B
 …
         release B
 release A
+\end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+acquire A
+        acquire B
+                signal B
+        release B
+release A
+\end{lstlisting}
+\end{tabular}
+\end{center}
+Also easy : like uC++
+\begin{center}
+\begin{tabular}{ c @{\hskip 0.65in} c }
+\begin{lstlisting}[language=Pseudo]
+acquire A & B
+        wait A & B
+release A & B
+\end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+acquire A & B
+        signal A & B
+release A & B
+\end{lstlisting}
+\end{tabular}
+\end{center}
+Simplest extension : can be made like uC++ by tying B to A
+\begin{center}
+\begin{tabular}{ c @{\hskip 0.65in} c }
+\begin{lstlisting}[language=Pseudo]
+\end{pseudo}
+\columnbreak
+\begin{pseudo}
+acquire B
+        signal B
+release B
+\end{pseudo}
+\end{multicols}
+While these cases can cause some deadlock issues, we consider that these issues are only a symptom of the fact that locks, and by extension monitors, are not perfectly composable. However, for monitors as for locks, it is possible to write program that using nesting without encountering any problems if they are nested carefully.
+The next example is where \gls{group-acquire} adds a significant layer of complexity to the internal signalling semantics.
+\begin{multicols}{2}
+\begin{pseudo}
 acquire A
         // Code Section 1
         acquire B
+        acquire A & B
                 // Code Section 2
                 wait A & B
                 // Code Section 3
         release B
+        release A & B
         // Code Section 4
 release A
+\end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+\end{pseudo}
+\columnbreak
+\begin{pseudo}
 acquire A
         // Code Section 5
         acquire B
+        acquire A & B
                 // Code Section 6
                 signal A & B
                 // Code Section 7
         release B
+        release A & B
         // Code Section 8
 release A
+\end{lstlisting}
+\end{tabular}
+\end{center}
+Hard extension :
+Incorrect options for the signal :
+\begin{description}
+ \item[-] Release B and baton pass after Code Section 8 : Passing b without having it
+ \item[-] Keep B during Code Section 8 : Can lead to deadlocks since we secretly keep a lock longer than specified by the user
+ \item[-] Instead of release B transfer A and B to waiter then try to reacquire A before running Code Section 8 : This allows barging
+\end{description}
+Since we don't want barging we need to pass A \& B and somehow block and get A back.
+\begin{center}
+\begin{tabular}{ c @{\hskip 0.65in} c }
+\begin{lstlisting}[language=Pseudo]
+\end{pseudo}
+\end{multicols}
+It is particularly important to pay attention to code sections 8 and 3 which are where the existing semantics of internal scheduling are undefined. The root of the problem is that \gls{group-acquire} is used in a context where one of the monitors is already acquired. As mentionned in previous sections, monitors support multiple acquiring which means the that nesting \gls{group-acquire} can be done safely. However, in the context of internal scheduling it is important to define the behaviour of the previous pseudo-code. When the signaller thread reaches the location where it should "release A \& B", it actually only needs to release the monitor B. Since the other thread is waiting on monitor B, the signaller thread cannot simply release the monitor into the wild. This would mean that the waiting thread would have to reacquire the monitor and would therefore open the door to barging threads. Since the signalling thread still needs the monitor A, simply transferring ownership to the waiting thread is not an option because it would pottentially violate mutual exclusion. We are therefore left with three options :
+\subsubsection{Delaying signals}
+The first more obvious solution to solve the problem of multi-monitor scheduling is to keep ownership of all locks until the last lock is ready to be transferred. It can be argued that that moment is the correct time to transfer ownership when the last lock is no longer needed is what fits most closely to the behaviour of single monitor scheduling. However, this solution can become much more complicated depending on the content of the code section 8. Indeed, nothing prevents a user from signalling monitor A on a different condition variable. In that case, if monitor B is transferred with monitor A, then it means the system needs to handle threads having ownership on more monitors than expected and how to tie monitors together. On the other hand if the signalling thread only transfers monitor A then somehow both monitors A and B have to be transferred to the waiting thread from two different threads. While this solution may work, it was not fully explored because there is no apparent upper bound on the complexity of ownership transfer.
+\subsubsection{Dependency graphs}
+In the previous pseudo-code, there is a solution which would statisfy both barging prevention and mutual exclusion. If ownership of both monitors is transferred to the waiter when the signaller releases A and then the waiter transfers back ownership of A when it releases it then the problem is solved. This is the second solution. The problem it encounters is that it effectively boils down to resolving a dependency graph of ownership requirements. Here even the simplest of code snippets requires two transfers and it seems to increase in a manner closer to polynomial. For example the following code which is just a direct extension to three monitors requires at least three ownership transfer and has multiple solutions.
+\begin{multicols}{2}
+\begin{pseudo}
 acquire A
         acquire B
                 acquire C
                         wait A & B & C
+: release C
+: release B
+: release A
+\end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+                release C
+        release B
+release A
+\end{pseudo}
+\columnbreak
+\begin{pseudo}
 acquire A
         acquire B
                 acquire C
                         signal A & B & C
+: release C
+: release B
+: release A
+\end{lstlisting}
+\end{tabular}
+\end{center}
+To prevent barging :
+\begin{description}
+ \item[-] When the signaller hits 4 : pass A, B, C to waiter
+ \item[-] When the waiter hits 2 : pass A, B to signaller
+ \item[-] When the signaller hits 5 : pass A to waiter
+\end{description}
+\begin{center}
+\begin{tabular}{ c @{\hskip 0.65in} c }
+\begin{lstlisting}[language=Pseudo]
+                release C
+        release B
+release A
+\end{pseudo}
+\end{multicols}
+\subsubsection{Partial signalling}
+Finally, the solution that was chosen for \CFA is to use partial signalling. Consider the following case :
+\begin{multicols}{2}
+\begin{pseudo}[numbers=left]
 acquire A
+        acquire C
+                acquire B
+                        wait A & B & C
+: release B
+: release C
+: release A
+\end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+acquire B
+        acquire A
+                acquire C
+                        signal A & B & C
+: release C
+: release A
+: release B
+\end{lstlisting}
+\end{tabular}
+\end{center}
+To prevent barging : When the signaller hits 4 : pass A, B, C to waiter. When the waiter hits 1 it must release B,
+\begin{description}
+ \item[-]
+ \item[-] When the waiter hits 1 : pass A, B to signaller
+ \item[-] When the signaller hits 5 : pass A, B to waiter
+ \item[-] When the waiter hits 2 : pass A to signaller
+\end{description}
+        acquire A & B
+                wait A & B
+        release A & B
+release A
+\end{pseudo}
+\columnbreak
+\begin{pseudo}[numbers=left, firstnumber=6]
+acquire A
+        acquire A & B
+                signal A & B
+        release A & B
+        // ... More code
+release A
+\end{pseudo}
+\end{multicols}
+The partial signalling solution transfers ownership of monitor B at lines 10 but does not wake the waiting thread since it is still using monitor A. Only when it reaches line 11 does it actually wakeup the waiting thread. This solution has the benefit that complexity is encapsulated in to only two actions, passing monitors to the next owner when they should be release and conditionnaly waking threads if all conditions are met. Contrary to the other solutions, this solution quickly hits an upper bound on complexity of implementation.
+% Hard extension :
+% Incorrect options for the signal :
+% \begin{description}
+%  \item[-] Release B and baton pass after Code Section 8 : Passing b without having it
+%  \item[-] Keep B during Code Section 8 : Can lead to deadlocks since we secretly keep a lock longer than specified by the user
+%  \item[-] Instead of release B transfer A and B to waiter then try to reacquire A before running Code Section 8 : This allows barging
+% \end{description}
+% Since we don't want barging we need to pass A \& B and somehow block and get A back.
+% \begin{center}
+% \begin{tabular}{ c @{\hskip 0.65in} c }
+% \begin{lstlisting}[language=Pseudo]
+% acquire A
+%       acquire B
+%               acquire C
+%                       wait A & B & C
+%               1: release C
+%       2: release B
+% 3: release A
+% \end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+% acquire A
+%       acquire B
+%               acquire C
+%                       signal A & B & C
+%               4: release C
+%       5: release B
+% 6: release A
+% \end{lstlisting}
+% \end{tabular}
+% \end{center}
+% To prevent barging :
+% \begin{description}
+%  \item[-] When the signaller hits 4 : pass A, B, C to waiter
+%  \item[-] When the waiter hits 2 : pass A, B to signaller
+%  \item[-] When the signaller hits 5 : pass A to waiter
+% \end{description}
+% \begin{center}
+% \begin{tabular}{ c @{\hskip 0.65in} c }
+% \begin{lstlisting}[language=Pseudo]
+% acquire A
+%       acquire C
+%               acquire B
+%                       wait A & B & C
+%               1: release B
+%       2: release C
+% 3: release A
+% \end{lstlisting}&\begin{lstlisting}[language=Pseudo]
+% acquire B
+%       acquire A
+%               acquire C
+%                       signal A & B & C
+%               4: release C
+%       5: release A
+% 6: release B
+% \end{lstlisting}
+% \end{tabular}
+% \end{center}
+% To prevent barging : When the signaller hits 4 : pass A, B, C to waiter. When the waiter hits 1 it must release B,
+% \begin{description}
+%  \item[-]
+%  \item[-] When the waiter hits 1 : pass A, B to signaller
+%  \item[-] When the signaller hits 5 : pass A, B to waiter
+%  \item[-] When the waiter hits 2 : pass A to signaller
+% \end{description}
 % Monitors also need to schedule waiting threads internally as a mean of synchronization. Internal scheduling is one of the simple examples of such a feature. It allows users to declare condition variables and have threads wait and signaled from them. Here is a simple example of such a technique :
 …
 % #        #   #     #    ###    #     # #     # #     # #       #     #
 % ####### #     #    #    ###     #####   #####  #     # ####### ######
+\newpage
+\subsection{External scheduling} \label{extsched}
+\section{External scheduling} \label{extsched}
 An alternative to internal scheduling is to use external scheduling instead. This method is more constrained and explicit which may help users tone down the undeterministic nature of concurrency. Indeed, as the following examples demonstrates, external scheduling allows users to wait for events from other threads without the concern of unrelated events occuring. External scheduling can generally be done either in terms of control flow (ex: \uC) or in terms of data (ex: Go). Of course, both of these paradigms have their own strenghts and weaknesses but for this project control flow semantics where chosen to stay consistent with the rest of the languages semantics. Two challenges specific to \CFA arise when trying to add external scheduling with loose object definitions and multi-monitor routines. The following example shows a simple use \code{accept} versus \code{wait}/\code{signal} and its advantages.
 …
 % ####### ####### #######  #####  #######    ####### ######   #####   #####
 \subsubsection{Loose object definitions}
+\subsection{Loose object definitions}
 In \uC, monitor declarations include an exhaustive list of monitor operations. Since \CFA is not object oriented it becomes both more difficult to implement but also less clear for the user :
 …
 \end{center}
 For the \pseudo{monitor is free} condition it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pseudo{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure :
+For the \pscode{monitor is free} condition it is easy to implement a check that can evaluate the condition in a few instruction. However, a fast check for \pscode{monitor accepts me} is much harder to implement depending on the constraints put on the monitors. Indeed, monitors are often expressed as an entry queue and some acceptor queue as in the following figure :
 \begin{center}
 …
 % #     #  #####  #######    #    ###    #     # ####### #     #
 \subsubsection{Multi-monitor scheduling}
+\subsection{Multi-monitor scheduling}
 External scheduling, like internal scheduling, becomes orders of magnitude more complex when we start introducing multi-monitor syntax. Even in the simplest possible case some new semantics need to be established :
 …
 \subsubsection{Implementation Details: External scheduling queues}
+\subsection{Implementation Details: External scheduling queues}
 To support multi-monitor external scheduling means that some kind of entry-queues must be used that is aware of both monitors. However, acceptable routines must be aware of the entry queues which means they must be stored inside at least one of the monitors that will be acquired. This in turn adds the requirement a systematic algorithm of disambiguating which queue is relavant regardless of user ordering. The proposed algorithm is to fall back on monitors lock ordering and specify that the monitor that is acquired first is the lock with the relevant entry queue. This assumes that the lock acquiring order is static for the lifetime of all concerned objects but that is a reasonnable constraint. This algorithm choice has two consequences, the entry queue of the highest priority monitor is no longer a true FIFO queue and the queue of the lowest priority monitor is both required and probably unused. The queue can no longer be a FIFO queue because instead of simply containing the waiting threads in order arrival, they also contain the second mutex. Therefore, another thread with the same highest priority monitor but a different lowest priority monitor may arrive first but enter the critical section after a thread with the correct pairing. Secondly, since it may not be known at compile time which monitor will be the lowest priority monitor, every monitor needs to have the correct queues even though it is probable that half the multi-monitor queues will go unused for the entire duration of the program.
 \subsection{Other concurrency tools}
+\section{Other concurrency tools}
 TO BE CONTINUED...
 …
-\newpage
 % ######     #    ######     #    #       #       ####### #       ###  #####  #     #
 % #     #   # #   #     #   # #   #       #       #       #        #  #     # ##   ##
 …
 % #       #     # #    #  #     # #       #       #       #        #  #     # #     #
 % #       #     # #     # #     # ####### ####### ####### ####### ###  #####  #     #
 \section{Parallelism}
+\chapter{Parallelism}
 Historically, computer performance was about processor speeds and instructions count. However, with heat dissipation being a direct consequence of speed increase, parallelism has become the new source for increased performance~\cite{Sutter05, Sutter05b}. In this decade, it is not longer reasonnable to create a high-performance application without caring about parallelism. Indeed, parallelism is an important aspect of performance and more specifically throughput and hardware utilization. The lowest-level approach of parallelism is to use \glspl{kthread} in combination with semantics like \code{fork}, \code{join}, etc. However, since these have significant costs and limitations, \glspl{kthread} are now mostly used as an implementation tool rather than a user oriented one. There are several alternatives to solve these issues that all have strengths and weaknesses. While there are many variations of the presented paradigms, most of these variations do not actually change the guarantees or the semantics, they simply move costs in order to achieve better performance for certain workloads.
+\section{Paradigm}
 \subsection{User-level threads}
 A direct improvement on the \gls{kthread} approach is to use \glspl{uthread}. These threads offer most of the same features that the operating system already provide but can be used on a much larger scale. This approach is the most powerfull solution as it allows all the features of multi-threading, while removing several of the more expensives costs of using kernel threads. The down side is that almost none of the low-level threading problems are hidden, users still have to think about data races, deadlocks and synchronization issues. These issues can be somewhat alleviated by a concurrency toolkit with strong garantees but the parallelism toolkit offers very little to reduce complexity in itself.
 …
 Examples of languages that support \glspl{uthread} are Erlang~\cite{Erlang} and \uC~\cite{uC++book}.
 \subsubsection{Fibers : user-level threads without preemption}
+\subsection{Fibers : user-level threads without preemption}
 A popular varient of \glspl{uthread} is what is often reffered to as \glspl{fiber}. However, \glspl{fiber} do not present meaningful semantical differences with \glspl{uthread}. Advocates of \glspl{fiber} list their high performance and ease of implementation as majors strenghts of \glspl{fiber} but the performance difference between \glspl{uthread} and \glspl{fiber} is controversial and the ease of implementation, while true, is a weak argument in the context of language design. Therefore this proposal largely ignore fibers.
 …
 % #     # #       #
 % #     # ####### #######
+\section{Putting it all together}
+\chapter{Putting it all together}
+\chapter{Conclusion}
 …
 % #       #     #    #    #     # #    #  #
 % #        #####     #     #####  #     # ######
 \section{Future work}
+\chapter{Future work}
 Concurrency and parallelism is still a very active field that strongly benefits from hardware advances. As such certain features that aren't necessarily mature enough in their current state could become relevant in the lifetime of \CFA.
 \subsection{Transactions}

doc/proposals/concurrency/style.tex

r6ac2ada	r1ed33fed
1	1	\input{common} % bespoke macros used in the document
	2	\input{cfa-format}
2	3
3	4	% \CFADefaultStyle

doc/proposals/concurrency/version

r6ac2ada	r1ed33fed
1		0.~~7.141~~
	1	0.8.2

src/CodeGen/CodeGenerator.cc

-              r6ac2ada
+              r1ed33fed
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus May  9 14:32:00 2017
 // Update Count     : 483
+// Last Modified On : Wed May 10 14:45:00 2017
+// Update Count     : 484
 //
 …
 namespace CodeGen {
         int CodeGenerator::tabsize = 4;
-        // Pseudo Function: output << lineDirective(*currentNode);
-    struct lineDirective {
-        CodeLocation const & loc;
-                lineDirective(CodeLocation const & location) : loc(location) {}
-                lineDirective(BaseSyntaxNode const * node) : loc(node->location) {}
-        };
-        std::ostream & operator<<(std::ostream & out, lineDirective const & ld) {
-                if (ld.loc.isSet())
-                        return out << "\n# " << ld.loc.linenumber << " \""
-                                << ld.loc.filename << "\"\n";
-                return out << "\n// Unset Location\n";
+        }
         // the kinds of statements that would ideally be followed by whitespace
 …
+        }
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ) {}
+        CodeGenerator::LineMarker::LineMarker(
+                        CodeLocation const & loc, bool toPrint) :
+                loc(loc), toPrint(toPrint)
+        {}
+        CodeGenerator::LineMarker CodeGenerator::lineDirective(
+                        BaseSyntaxNode const * node) {
+                return LineMarker(node->location, lineMarks);
+        }
+        std::ostream & operator<<(std::ostream & out,
+                        CodeGenerator::LineMarker const & marker) {
+                if (marker.toPrint && marker.loc.isSet()) {
+                        return out << "\n# " << marker.loc.linenumber << " \""
+                                << marker.loc.filename << "\"\n";
+                } else if (marker.toPrint) {
+                        return out << "\n/* Missing CodeLocation */\n";
+                } else {
+                return out;
+                }
+        }
+        CodeGenerator::CodeGenerator( std::ostream & os, bool pretty, bool genC, bool lineMarks ) : indent( *this), cur_indent( 0 ), insideFunction( false ), output( os ), printLabels( *this ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
         CodeGenerator::CodeGenerator( std::ostream & os, std::string init, int indentation, bool infunp )
 …
+                }
                 output << lineDirective( aggDecl ) << kind;
+                output << kind;
                 if ( aggDecl->get_name() != "" )
                         output << aggDecl->get_name();
 …
         void CodeGenerator::visit( UntypedTupleExpr * tupleExpr ) {
                 assertf( ! genC, "UntypedTupleExpr should not reach code generation." );
+                extension( tupleExpr );
                 output << "[";
                 genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
 …
         void CodeGenerator::visit( TupleExpr * tupleExpr ) {
                 assertf( ! genC, "TupleExpr should not reach code generation." );
+                extension( tupleExpr );
                 output << "[";
                 genCommaList( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end() );
                 output << "]";
+        }
+        void CodeGenerator::visit( TupleIndexExpr * tupleExpr ) {
+                assertf( ! genC, "TupleIndexExpr should not reach code generation." );
+                extension( tupleExpr );
+                tupleExpr->get_tuple()->accept( *this );
+                output << "." << tupleExpr->get_index();
+        }

src/CodeGen/CodeGenerator.h

-              r6ac2ada
+              r1ed33fed
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Mar  1 16:20:04 2017
 // Update Count     : 50
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May 10 10:57:00 2017
+// Update Count     : 51
 //
 …
 #include "SymTab/Indexer.h"
+#include "Common/utility.h"
 namespace CodeGen {
         class CodeGenerator : public Visitor {
 …
                 static int tabsize;
                 CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false );
+                CodeGenerator( std::ostream &os, bool pretty = false, bool genC = false, bool lineMarks = false );
                 CodeGenerator( std::ostream &os, std::string, int indent = 0, bool infun = false );
                 CodeGenerator( std::ostream &os, char *, int indent = 0, bool infun = false );
 …
                 virtual void visit( UntypedTupleExpr *tupleExpr );
                 virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( TupleIndexExpr * tupleExpr );
                 virtual void visit( TypeExpr *typeExpr );
                 virtual void visit( AsmExpr * );
 …
                 };
+                struct LineMarker {
+                        CodeLocation const & loc;
+                        bool toPrint;
+                        LineMarker(CodeLocation const & loc, bool toPrint);
+                };
+                LineMarker lineDirective(BaseSyntaxNode const * node);
                 void asmName( DeclarationWithType *decl );
 …
                 bool pretty = false;  // pretty print
                 bool genC = false;    // true if output has to be C code
+                bool lineMarks = false;
                 void printDesignators( std::list< Expression * > & );
 …
         /// returns C-compatible name of declaration
         std::string genName( DeclarationWithType * decl );
+        std::ostream & operator<<(std::ostream &,
+                CodeGenerator::LineMarker const &);
 } // namespace CodeGen

src/CodeGen/GenType.cc

-              r6ac2ada
+              r1ed33fed
         class GenType : public Visitor {
           public:
                 GenType( const std::string &typeString, bool pretty = false, bool genC = false );
+                GenType( const std::string &typeString, bool pretty = false, bool genC = false, bool lineMarks = false );
                 std::string get_typeString() const { return typeString; }
                 void set_typeString( const std::string &newValue ) { typeString = newValue; }
 …
                 bool pretty = false; // pretty print
                 bool genC = false;   // generating C code?
+                bool lineMarks = false;
         };
         std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC ) {
                 GenType gt( baseString, pretty, genC );
+        std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
+                GenType gt( baseString, pretty, genC, lineMarks );
                 std::ostringstream os;
                 if ( ! type->get_attributes().empty() ) {
                         CodeGenerator cg( os, pretty, genC );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         cg.genAttributes( type->get_attributes() );
                 } // if
 …
+  }
         GenType::GenType( const std::string &typeString, bool pretty, bool genC ) : typeString( typeString ), pretty( pretty ), genC( genC ) {}
+        GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
         void GenType::visit( VoidType *voidType ) {
 …
                 } // if
                 if ( dimension != 0 ) {
                         CodeGenerator cg( os, pretty, genC );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         dimension->accept( cg );
                 } else if ( isVarLen ) {
 …
                         } // if
                 } else {
                         CodeGenerator cg( os, pretty, genC );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         os << "(" ;
 …
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         std::ostringstream os;
                         CodeGenerator cg( os, pretty, genC );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         os << "forall(";
                         cg.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() );
 …
                 if ( ! refType->get_parameters().empty() ) {
                         std::ostringstream os;
                         CodeGenerator cg( os, pretty, genC );
+                        CodeGenerator cg( os, pretty, genC, lineMarks );
                         os << "(";
                         cg.genCommaList( refType->get_parameters().begin(), refType->get_parameters().end() );
 …
                 for ( Type * t : *tupleType ) {
                         i++;
                         os << genType( t, "", pretty, genC ) << (i == tupleType->size() ? "" : ", ");
+                        os << genType( t, "", pretty, genC, lineMarks ) << (i == tupleType->size() ? "" : ", ");
+                }
                 os << "]";

src/CodeGen/GenType.h

r6ac2ada	r1ed33fed
21	21
22	22	namespace CodeGen {
23		std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false );
	23	std::string genType( Type *type, const std::string &baseString, bool pretty = false, bool genC = false, bool lineMarks = false );
24	24	std::string genPrettyType( Type * type, const std::string & baseString );
25	25	} // namespace CodeGen

src/CodeGen/Generate.cc

-              r6ac2ada
+              r1ed33fed
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun  4 14:04:25 2015
 // Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May 19 13:05:00 2017
+// Update Count     : 6
 //
 …
 namespace CodeGen {
         void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC ) {
                 CodeGen::CodeGenerator cgv( os, pretty, generateC );
+        void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC, bool lineMarks ) {
+                CodeGen::CodeGenerator cgv( os, pretty, generateC, lineMarks );
                 for ( auto & dcl : translationUnit ) {
                         if ( LinkageSpec::isGeneratable( dcl->get_linkage() ) && (doIntrinsics || ! LinkageSpec::isBuiltin( dcl->get_linkage() ) ) ) {
+                                os << cgv.lineDirective(dcl);
                                 dcl->accept(cgv);
                                 if ( doSemicolon( dcl ) ) {
 …
                         os << CodeGen::genPrettyType( type, "" );
                 } else {
                         CodeGen::CodeGenerator cgv( os, true, false );
+                        CodeGen::CodeGenerator cgv( os, true, false, false );
                         node->accept( cgv );
+                }

src/CodeGen/Generate.h

r6ac2ada	r1ed33fed
24	24	namespace CodeGen {
25	25	/// Generates code. doIntrinsics determines if intrinsic functions are printed, pretty formats output nicely (e.g., uses unmangled names, etc.), generateC is true when the output must consist only of C code (allows some assertions, etc.)
26		void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false );
	26	void generate( std::list< Declaration* > translationUnit, std::ostream &os, bool doIntrinsics, bool pretty, bool generateC = false , bool lineMarks = false );
27	27
28	28	/// Generate code for a single node -- helpful for debugging in gdb

src/Common/utility.h

-              r6ac2ada
+              r1ed33fed
         std::string filename;
     /// Create a new unset CodeLocation.
+        /// Create a new unset CodeLocation.
         CodeLocation()
                 : linenumber( -1 )
 …
         {}
     /// Create a new CodeLocation with the given values.
+        /// Create a new CodeLocation with the given values.
         CodeLocation( const char* filename, int lineno )
                 : linenumber( lineno )
 …
         {}
     bool isSet () const {
         return -1 != linenumber;
+    }
     bool isUnset () const {
         return !isSet();
+    }
+        bool isSet () const {
+                return -1 != linenumber;
+        }
+        bool isUnset () const {
+                return !isSet();
+        }
         void unset () {
 …
         return location.isSet() ? location.filename + ":" + std::to_string(location.linenumber) + " " : "";
+}
 #endif // _UTILITY_H

src/GenPoly/Box.cc

-              r6ac2ada
+              r1ed33fed
                                                 arg = new AddressExpr( arg );
+                                        }
+                                        if ( ! ResolvExpr::typesCompatible( param, arg->get_result(), SymTab::Indexer() ) ) {
+                                                // silence warnings by casting boxed parameters when the actual type does not match up with the formal type.
+                                                arg = new CastExpr( arg, param->clone() );
+                                        }
                                 } else {
                                         // use type computed in unification to declare boxed variables
 …
                                 } // if
                                 UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) );
+                                UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                deref->get_args().push_back( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) );
+                                UntypedExpr *deref = UntypedExpr::createDeref( new CastExpr( new VariableExpr( *param++ ), new PointerType( Type::Qualifiers(), realType->get_returnVals().front()->get_type()->clone() ) ) );
                                 assign->get_args().push_back( deref );
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
 …
                 Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
-                        // maybe need access to the env when mutating the expr
-                        if ( Expression * expr = returnStmt->get_expr() ) {
-                                if ( expr->get_env() ) {
-                                        env = expr->get_env();
+                                }
+                        }
                         if ( retval && returnStmt->get_expr() ) {
                                 assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
 …
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
                                 if ( functionDecl->get_name() != "?=?" && ! isPrefix( functionDecl->get_name(), "_thunk" ) && ! isPrefix( functionDecl->get_name(), "_adapter" ) ) { // xxx - remove check for ?=? once reference types are in; remove check for prefix once thunks properly use ctor/dtors
+                                if ( ! isPrefix( functionDecl->get_name(), "_thunk" ) && ! isPrefix( functionDecl->get_name(), "_adapter" ) ) { // xxx - remove check for prefix once thunks properly use ctor/dtors
                                         assert( ftype->get_returnVals().size() == 1 );
                                         DeclarationWithType * retval = ftype->get_returnVals().front();
 …
                                         Type *declType = objectDecl->get_type();
                                         std::string bufName = bufNamer.newName();
                                         ObjectDecl *newBuf = new ObjectDecl( bufName, Type::StorageClasses(), LinkageSpec::C, 0,
                                                 new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
+                                        ObjectDecl *newBuf = new ObjectDecl( bufName, Type::StorageClasses(), LinkageSpec::C, 0,
+                                                new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
                                                 true, false, std::list<Attribute*>{ new Attribute( std::string{"aligned"}, std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
                                         stmtsToAdd.push_back( new DeclStmt( noLabels, newBuf ) );
 …
+                }
-                /// Returns an expression dereferenced n times
-                Expression *makeDerefdVar( Expression *derefdVar, long n ) {
-                        for ( int i = 1; i < n; ++i ) {
-                                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
-                                derefExpr->get_args().push_back( derefdVar );
-                                // xxx - should set results on derefExpr
-                                derefdVar = derefExpr;
+                        }
-                        return derefdVar;
+                }
                 Expression *PolyGenericCalculator::mutate( MemberExpr *memberExpr ) {
                         // mutate, exiting early if no longer MemberExpr
 …
                         if ( ! memberExpr ) return expr;
-                        // get declaration for base struct, exiting early if not found
-                        int varDepth;
-                        VariableExpr *varExpr = getBaseVar( memberExpr->get_aggregate(), &varDepth );
-                        if ( ! varExpr ) return memberExpr;
-                        ObjectDecl *objectDecl = dynamic_cast< ObjectDecl* >( varExpr->get_var() );
-                        if ( ! objectDecl ) return memberExpr;
                         // only mutate member expressions for polymorphic types
                         int tyDepth;
                         Type *objectType = hasPolyBase( objectDecl->get_type(), scopeTyVars, &tyDepth );
+                        Type *objectType = hasPolyBase( memberExpr->get_aggregate()->get_result(), scopeTyVars, &tyDepth );
                         if ( ! objectType ) return memberExpr;
                         findGeneric( objectType ); // ensure layout for this type is available
 …
                                 fieldLoc->get_args().push_back( aggr );
                                 fieldLoc->get_args().push_back( makeOffsetIndex( objectType, i ) );
+                                fieldLoc->set_result( memberExpr->get_result()->clone() );
                                 newMemberExpr = fieldLoc;
                         } else if ( dynamic_cast< UnionInstType* >( objectType ) ) {
+                                // union members are all at offset zero, so build appropriately-dereferenced variable
+                                newMemberExpr = makeDerefdVar( varExpr->clone(), varDepth );
+                                // union members are all at offset zero, so just use the aggregate expr
+                                Expression * aggr = memberExpr->get_aggregate()->clone();
+                                delete aggr->get_env(); // xxx - there's a problem with keeping the env for some reason, so for now just get rid of it
+                                aggr->set_env( nullptr );
+                                newMemberExpr = aggr;
+                                newMemberExpr->set_result( memberExpr->get_result()->clone() );
                         } else return memberExpr;
                         assert( newMemberExpr );
 …
                                 // Not all members of a polymorphic type are themselves of polymorphic type; in this case the member expression should be wrapped and dereferenced to form an lvalue
                                 CastExpr *ptrCastExpr = new CastExpr( newMemberExpr, new PointerType( Type::Qualifiers(), memberType->clone() ) );
+                                UntypedExpr *derefExpr = new UntypedExpr( new NameExpr( "*?" ) );
+                                derefExpr->get_args().push_back( ptrCastExpr );
+                                UntypedExpr *derefExpr = UntypedExpr::createDeref( ptrCastExpr );
                                 newMemberExpr = derefExpr;
+                        }

src/InitTweak/FixInit.cc

-              r6ac2ada
+              r1ed33fed
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assert( ftype );
                                         if ( (isConstructor( funcDecl->get_name() ) || funcDecl->get_name() == "?=?") && ftype->get_parameters().size() == 2 ) {
+                                        if ( isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
 …
                                                 if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
+                                                        // optimization: don't need to copy construct in order to call a copy constructor or
+                                                        // assignment operator
+                                                        // optimization: don't need to copy construct in order to call a copy constructor
                                                         return appExpr;
                                                 } // if
 …
                                 assert( ! stmtExpr->get_returnDecls().empty() );
                                 body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                        }
+                        stmtExpr->get_returnDecls().clear();
+                        stmtExpr->get_dtors().clear();
+                                stmtExpr->get_returnDecls().clear();
+                                stmtExpr->get_dtors().clear();
+                        }
+                        assert( stmtExpr->get_returnDecls().empty() );
+                        assert( stmtExpr->get_dtors().empty() );
                         return stmtExpr;
+                }
 …
                         stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
                         unqMap[unqExpr->get_id()] = unqExpr;
+                        if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
+                                stmtsToAdd.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
+                        } else { // remember dtors for last instance of unique expr
+                                dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
+                        }
                         if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
                                 // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
 …
                                 getCallArg( deref, 0 ) = unqExpr;
                                 addDeref.insert( unqExpr->get_id() );
-                                if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
-                                        stmtsToAdd.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
-                                } else { // remember dtors for last instance of unique expr
-                                        dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
+                                }
                                 return deref;
+                        }

src/InitTweak/GenInit.cc

-              r6ac2ada
+              r1ed33fed
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
                 // is being returned
+                // Note: under the assumption that assignments return *this, checking for ?=? here is an optimization, since it shouldn't be necessary to copy construct `this`. This is a temporary optimization until reference types are added, at which point this should be removed, along with the analogous optimization in copy constructor generation.
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && funcName != "?=?" && ! returnVals.front()->get_type()->get_lvalue() ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && ! returnVals.front()->get_type()->get_lvalue() ) {
                         // explicitly construct the return value using the return expression and the retVal object
                         assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );

src/main.cc

-              r6ac2ada
+              r1ed33fed
 //
 // Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
 …
 // Author           : Richard C. Bilson
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 14 14:35:54 2016
 // Update Count     : 436
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed May 10 14:45:00 2017
+// Update Count     : 437
 //
 …
         errorp = false,
         codegenp = false,
+        prettycodegenp = false;
+        prettycodegenp = false,
+        nolinemarks = false;
 static void parse_cmdline( int argc, char *argv[], const char *& filename );
 …
                 CodeTools::fillLocations( translationUnit );
                 CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true );
+                CodeGen::generate( translationUnit, *output, ! noprotop, prettycodegenp, true, ! nolinemarks );
                 CodeGen::FixMain::fix( *output, treep ? "../prelude/bootloader.c" : CFA_LIBDIR "/bootloader.c" );
 …
         } catch ( CompilerError &e ) {
                 cerr << "Compiler Error: " << e.get_what() << endl;
                 cerr << "(please report bugs to " << endl;
+                cerr << "(please report bugs to [REDACTED])" << endl;
                 if ( output != &cout ) {
                         delete output;
 …
         int c;
         while ( (c = getopt_long( argc, argv, "abBcdefglmnpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcdefglLmnpqrstTvyzZD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
                   case Ast:
 …
                   case 'l':                                                                             // generate libcfa.c
                         libcfap = true;
+                        break;
+                  case 'L':                                                                             // surpress lines marks
+                        nolinemarks = true;
                         break;
                   case Nopreamble:

src/prelude/Makefile.am

r6ac2ada	r1ed33fed
42	42
43	43	bootloader.c : bootloader.cf prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
44		${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpm bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
	44	${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
45	45
46	46	MAINTAINERCLEANFILES = builtins.c builtins.cf extras.cf bootloader.c ${addprefix ${libdir}/,${cfalib_DATA}} ${addprefix ${libdir}/,${lib_LIBRARIES}}

src/prelude/Makefile.in

r6ac2ada	r1ed33fed
439	439
440	440	bootloader.c : bootloader.cf prelude.cf extras.cf builtins.cf ${abs_top_srcdir}/src/driver/cfa-cpp
441		${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpm bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
	441	${AM_V_GEN}${abs_top_srcdir}/src/driver/cfa-cpp -tpmL bootloader.cf $@ # use src/cfa-cpp as not in lib until after install
442	442
443	443	# Tell versions [3.59,3.63) of GNU make to not export all variables.

src/tests/.expect/32/KRfunctions.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+    struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    return ((struct S )___src__2sS_1);
+    ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
+    return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __i__i_1){

src/tests/.expect/32/attributes.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    return ((struct __anonymous0 )___src__13s__anonymous0_1);
+    struct __anonymous0 ___ret__13s__anonymous0_1;
+    ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 __attribute__ ((unused)) struct Agn1;
 …
+}
 static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+    return ((struct Agn2 )___src__5sAgn2_1);
+    struct Agn2 ___ret__5sAgn2_1;
+    ((void)___constructor__F_P5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
+    return ((struct Agn2 )___ret__5sAgn2_1);
+}
 enum __attribute__ ((unused)) __anonymous1 {
 …
+}
 static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1){
+    struct Fdl ___ret__4sFdl_1;
     ((void)((*___dst__P4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     ((void)((*___dst__P4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
 …
     ((void)((*___dst__P4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     ((void)((*___dst__P4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
+    return ((struct Fdl )___src__4sFdl_1);
+    ((void)___constructor__F_P4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
+    return ((struct Fdl )___ret__4sFdl_1);
+}
 static inline void ___constructor__F_P4sFdli_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1){
 …
+    }
     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
+        struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__P13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
+        return ((struct __anonymous4 )___src__13s__anonymous4_2);
+        ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
+        return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+    }
     inline void ___constructor__F_P13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, int __i__i_2){
 …
+    }
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
+        return ((enum __anonymous5 )((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2));
+        enum __anonymous5 ___ret__13e__anonymous5_2;
+        ((void)(___ret__13e__anonymous5_2=((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+    }
     ((void)sizeof(enum __anonymous5 ));
 …
+}
 static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){
+    return ((struct Vad )___src__4sVad_1);
+}
+    struct Vad ___ret__4sVad_1;
+    ((void)___constructor__F_P4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    return ((struct Vad )___ret__4sVad_1);
+}

src/tests/.expect/32/declarationSpecifier.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__P13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
+    return ((struct __anonymous0 )___src__13s__anonymous0_1);
+    ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 static inline void ___constructor__F_P13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, int __i__i_1){
 …
+}
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
+    struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__P13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
+    return ((struct __anonymous1 )___src__13s__anonymous1_1);
+    ((void)___constructor__F_P13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
+    return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+}
 static inline void ___constructor__F_P13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, int __i__i_1){
 …
+}
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+    struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__P13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
+    return ((struct __anonymous2 )___src__13s__anonymous2_1);
+    ((void)___constructor__F_P13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
+    return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+}
 static inline void ___constructor__F_P13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, int __i__i_1){
 …
+}
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
+    struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__P13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
+    return ((struct __anonymous3 )___src__13s__anonymous3_1);
+    ((void)___constructor__F_P13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
+    return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+}
 static inline void ___constructor__F_P13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, int __i__i_1){
 …
+}
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
+    struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__P13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
+    return ((struct __anonymous4 )___src__13s__anonymous4_1);
+    ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
+    return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+}
 static inline void ___constructor__F_P13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, int __i__i_1){
 …
+}
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
+    struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__P13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
+    return ((struct __anonymous5 )___src__13s__anonymous5_1);
+    ((void)___constructor__F_P13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
+    return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+}
 static inline void ___constructor__F_P13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, int __i__i_1){
 …
+}
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
+    struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__P13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
+    return ((struct __anonymous6 )___src__13s__anonymous6_1);
+    ((void)___constructor__F_P13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
+    return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+}
 static inline void ___constructor__F_P13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, int __i__i_1){
 …
+}
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
+    struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__P13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
+    return ((struct __anonymous7 )___src__13s__anonymous7_1);
+    ((void)___constructor__F_P13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
+    return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+}
 static inline void ___constructor__F_P13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, int __i__i_1){
 …
+}
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
+    struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__P13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
+    return ((struct __anonymous8 )___src__13s__anonymous8_1);
+    ((void)___constructor__F_P13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
+    return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+}
 static inline void ___constructor__F_P13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, short __i__s_1){
 …
+}
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
+    struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__P13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
+    return ((struct __anonymous9 )___src__13s__anonymous9_1);
+    ((void)___constructor__F_P13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
+    return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+}
 static inline void ___constructor__F_P13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, short __i__s_1){
 …
+}
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
+    struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__P14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
+    return ((struct __anonymous10 )___src__14s__anonymous10_1);
+    ((void)___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
+    return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+}
 static inline void ___constructor__F_P14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, short __i__s_1){
 …
+}
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
+    struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__P14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
+    return ((struct __anonymous11 )___src__14s__anonymous11_1);
+    ((void)___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
+    return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+}
 static inline void ___constructor__F_P14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, short __i__s_1){
 …
+}
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
+    struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__P14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
+    return ((struct __anonymous12 )___src__14s__anonymous12_1);
+    ((void)___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
+    return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+}
 static inline void ___constructor__F_P14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, short __i__s_1){
 …
+}
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
+    struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__P14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
+    return ((struct __anonymous13 )___src__14s__anonymous13_1);
+    ((void)___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
+    return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+}
 static inline void ___constructor__F_P14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, short __i__s_1){
 …
+}
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
+    struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__P14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
+    return ((struct __anonymous14 )___src__14s__anonymous14_1);
+    ((void)___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
+    return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+}
 static inline void ___constructor__F_P14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, short __i__s_1){
 …
+}
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
+    struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__P14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
+    return ((struct __anonymous15 )___src__14s__anonymous15_1);
+    ((void)___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
+    return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+}
 static inline void ___constructor__F_P14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, short __i__s_1){
 …
+}
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
+    struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__P14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
+    return ((struct __anonymous16 )___src__14s__anonymous16_1);
+    ((void)___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
+    return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+}
 static inline void ___constructor__F_P14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, int __i__i_1){
 …
+}
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
+    struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__P14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
+    return ((struct __anonymous17 )___src__14s__anonymous17_1);
+    ((void)___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
+    return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+}
 static inline void ___constructor__F_P14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, int __i__i_1){
 …
+}
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
+    struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__P14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
+    return ((struct __anonymous18 )___src__14s__anonymous18_1);
+    ((void)___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
+    return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+}
 static inline void ___constructor__F_P14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, int __i__i_1){
 …
+}
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
+    struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__P14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
+    return ((struct __anonymous19 )___src__14s__anonymous19_1);
+    ((void)___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
+    return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+}
 static inline void ___constructor__F_P14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, int __i__i_1){
 …
+}
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
+    struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__P14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
+    return ((struct __anonymous20 )___src__14s__anonymous20_1);
+    ((void)___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
+    return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+}
 static inline void ___constructor__F_P14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, int __i__i_1){
 …
+}
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
+    struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__P14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
+    return ((struct __anonymous21 )___src__14s__anonymous21_1);
+    ((void)___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
+    return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+}
 static inline void ___constructor__F_P14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, int __i__i_1){
 …
+}
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
+    struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__P14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
+    return ((struct __anonymous22 )___src__14s__anonymous22_1);
+    ((void)___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
+    return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+}
 static inline void ___constructor__F_P14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, int __i__i_1){
 …
+}
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
+    struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__P14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
+    return ((struct __anonymous23 )___src__14s__anonymous23_1);
+    ((void)___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
+    return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+}
 static inline void ___constructor__F_P14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, int __i__i_1){

src/tests/.expect/32/extension.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+    struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
     ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
+    return ((struct S )___src__2sS_1);
+    ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
+    return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __a__i_1){
 …
+}
 static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
+    union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    return ((union U )___src__2uU_1);
+    ((void)___constructor__F_P2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
+    return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){

src/tests/.expect/32/gccExtensions.txt

-              r6ac2ada
+              r1ed33fed
+    }
     inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
+        struct S ___ret__2sS_2;
         ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
         ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        return ((struct S )___src__2sS_2);
+        ((void)___constructor__F_P2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
+        return ((struct S )___ret__2sS_2);
+    }
     inline void ___constructor__F_P2sSi_autogen___2(struct S *___dst__P2sS_2, int __a__i_2){
 …
+    }
     inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
+        struct s2 ___ret__3ss2_2;
         ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        return ((struct s2 )___src__3ss2_2);
+        ((void)___constructor__F_P3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
+        return ((struct s2 )___ret__3ss2_2);
+    }
     inline void ___constructor__F_P3ss2i_autogen___2(struct s2 *___dst__P3ss2_2, int __i__i_2){
 …
+    }
     inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
+        struct s3 ___ret__3ss3_2;
         ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        return ((struct s3 )___src__3ss3_2);
+        ((void)___constructor__F_P3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
+        return ((struct s3 )___ret__3ss3_2);
+    }
     inline void ___constructor__F_P3ss3i_autogen___2(struct s3 *___dst__P3ss3_2, int __i__i_2){
 …
+    }
     inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
+        struct s4 ___ret__3ss4_2;
         ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        return ((struct s4 )___src__3ss4_2);
+        ((void)___constructor__F_P3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
+        return ((struct s4 )___ret__3ss4_2);
+    }
     inline void ___constructor__F_P3ss4i_autogen___2(struct s4 *___dst__P3ss4_2, int __i__i_2){

src/tests/.expect/64/KRfunctions.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+    struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__i__i_1=___src__2sS_1.__i__i_1));
+    return ((struct S )___src__2sS_1);
+    ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
+    return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __i__i_1){

src/tests/.expect/64/attributes.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    return ((struct __anonymous0 )___src__13s__anonymous0_1);
+    struct __anonymous0 ___ret__13s__anonymous0_1;
+    ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 __attribute__ ((unused)) struct Agn1;
 …
+}
 static inline struct Agn2 ___operator_assign__F5sAgn2_P5sAgn25sAgn2_autogen___1(struct Agn2 *___dst__P5sAgn2_1, struct Agn2 ___src__5sAgn2_1){
+    return ((struct Agn2 )___src__5sAgn2_1);
+    struct Agn2 ___ret__5sAgn2_1;
+    ((void)___constructor__F_P5sAgn25sAgn2_autogen___1((&___ret__5sAgn2_1), ___src__5sAgn2_1));
+    return ((struct Agn2 )___ret__5sAgn2_1);
+}
 enum __attribute__ ((unused)) __anonymous1 {
 …
+}
 static inline struct Fdl ___operator_assign__F4sFdl_P4sFdl4sFdl_autogen___1(struct Fdl *___dst__P4sFdl_1, struct Fdl ___src__4sFdl_1){
+    struct Fdl ___ret__4sFdl_1;
     ((void)((*___dst__P4sFdl_1).__f1__i_1=___src__4sFdl_1.__f1__i_1));
     ((void)((*___dst__P4sFdl_1).__f2__i_1=___src__4sFdl_1.__f2__i_1));
 …
     ((void)((*___dst__P4sFdl_1).__f8__i_1=___src__4sFdl_1.__f8__i_1));
     ((void)((*___dst__P4sFdl_1).__f9__Pi_1=___src__4sFdl_1.__f9__Pi_1));
+    return ((struct Fdl )___src__4sFdl_1);
+    ((void)___constructor__F_P4sFdl4sFdl_autogen___1((&___ret__4sFdl_1), ___src__4sFdl_1));
+    return ((struct Fdl )___ret__4sFdl_1);
+}
 static inline void ___constructor__F_P4sFdli_autogen___1(struct Fdl *___dst__P4sFdl_1, int __f1__i_1){
 …
+    }
     inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, struct __anonymous4 ___src__13s__anonymous4_2){
+        struct __anonymous4 ___ret__13s__anonymous4_2;
         ((void)((*___dst__P13s__anonymous4_2).__i__i_2=___src__13s__anonymous4_2.__i__i_2));
+        return ((struct __anonymous4 )___src__13s__anonymous4_2);
+        ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___2((&___ret__13s__anonymous4_2), ___src__13s__anonymous4_2));
+        return ((struct __anonymous4 )___ret__13s__anonymous4_2);
+    }
     inline void ___constructor__F_P13s__anonymous4i_autogen___2(struct __anonymous4 *___dst__P13s__anonymous4_2, int __i__i_2){
 …
+    }
     inline enum __anonymous5 ___operator_assign__F13e__anonymous5_P13e__anonymous513e__anonymous5_intrinsic___2(enum __anonymous5 *___dst__P13e__anonymous5_2, enum __anonymous5 ___src__13e__anonymous5_2){
+        return ((enum __anonymous5 )((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2));
+        enum __anonymous5 ___ret__13e__anonymous5_2;
+        ((void)(___ret__13e__anonymous5_2=((*___dst__P13e__anonymous5_2)=___src__13e__anonymous5_2)) /* ?{} */);
+        return ((enum __anonymous5 )___ret__13e__anonymous5_2);
+    }
     ((void)sizeof(enum __anonymous5 ));
 …
+}
 static inline struct Vad ___operator_assign__F4sVad_P4sVad4sVad_autogen___1(struct Vad *___dst__P4sVad_1, struct Vad ___src__4sVad_1){
+    return ((struct Vad )___src__4sVad_1);
+}
+    struct Vad ___ret__4sVad_1;
+    ((void)___constructor__F_P4sVad4sVad_autogen___1((&___ret__4sVad_1), ___src__4sVad_1));
+    return ((struct Vad )___ret__4sVad_1);
+}

src/tests/.expect/64/declarationSpecifier.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct __anonymous0 ___operator_assign__F13s__anonymous0_P13s__anonymous013s__anonymous0_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, struct __anonymous0 ___src__13s__anonymous0_1){
+    struct __anonymous0 ___ret__13s__anonymous0_1;
     ((void)((*___dst__P13s__anonymous0_1).__i__i_1=___src__13s__anonymous0_1.__i__i_1));
+    return ((struct __anonymous0 )___src__13s__anonymous0_1);
+    ((void)___constructor__F_P13s__anonymous013s__anonymous0_autogen___1((&___ret__13s__anonymous0_1), ___src__13s__anonymous0_1));
+    return ((struct __anonymous0 )___ret__13s__anonymous0_1);
+}
 static inline void ___constructor__F_P13s__anonymous0i_autogen___1(struct __anonymous0 *___dst__P13s__anonymous0_1, int __i__i_1){
 …
+}
 static inline struct __anonymous1 ___operator_assign__F13s__anonymous1_P13s__anonymous113s__anonymous1_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, struct __anonymous1 ___src__13s__anonymous1_1){
+    struct __anonymous1 ___ret__13s__anonymous1_1;
     ((void)((*___dst__P13s__anonymous1_1).__i__i_1=___src__13s__anonymous1_1.__i__i_1));
+    return ((struct __anonymous1 )___src__13s__anonymous1_1);
+    ((void)___constructor__F_P13s__anonymous113s__anonymous1_autogen___1((&___ret__13s__anonymous1_1), ___src__13s__anonymous1_1));
+    return ((struct __anonymous1 )___ret__13s__anonymous1_1);
+}
 static inline void ___constructor__F_P13s__anonymous1i_autogen___1(struct __anonymous1 *___dst__P13s__anonymous1_1, int __i__i_1){
 …
+}
 static inline struct __anonymous2 ___operator_assign__F13s__anonymous2_P13s__anonymous213s__anonymous2_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, struct __anonymous2 ___src__13s__anonymous2_1){
+    struct __anonymous2 ___ret__13s__anonymous2_1;
     ((void)((*___dst__P13s__anonymous2_1).__i__i_1=___src__13s__anonymous2_1.__i__i_1));
+    return ((struct __anonymous2 )___src__13s__anonymous2_1);
+    ((void)___constructor__F_P13s__anonymous213s__anonymous2_autogen___1((&___ret__13s__anonymous2_1), ___src__13s__anonymous2_1));
+    return ((struct __anonymous2 )___ret__13s__anonymous2_1);
+}
 static inline void ___constructor__F_P13s__anonymous2i_autogen___1(struct __anonymous2 *___dst__P13s__anonymous2_1, int __i__i_1){
 …
+}
 static inline struct __anonymous3 ___operator_assign__F13s__anonymous3_P13s__anonymous313s__anonymous3_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, struct __anonymous3 ___src__13s__anonymous3_1){
+    struct __anonymous3 ___ret__13s__anonymous3_1;
     ((void)((*___dst__P13s__anonymous3_1).__i__i_1=___src__13s__anonymous3_1.__i__i_1));
+    return ((struct __anonymous3 )___src__13s__anonymous3_1);
+    ((void)___constructor__F_P13s__anonymous313s__anonymous3_autogen___1((&___ret__13s__anonymous3_1), ___src__13s__anonymous3_1));
+    return ((struct __anonymous3 )___ret__13s__anonymous3_1);
+}
 static inline void ___constructor__F_P13s__anonymous3i_autogen___1(struct __anonymous3 *___dst__P13s__anonymous3_1, int __i__i_1){
 …
+}
 static inline struct __anonymous4 ___operator_assign__F13s__anonymous4_P13s__anonymous413s__anonymous4_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, struct __anonymous4 ___src__13s__anonymous4_1){
+    struct __anonymous4 ___ret__13s__anonymous4_1;
     ((void)((*___dst__P13s__anonymous4_1).__i__i_1=___src__13s__anonymous4_1.__i__i_1));
+    return ((struct __anonymous4 )___src__13s__anonymous4_1);
+    ((void)___constructor__F_P13s__anonymous413s__anonymous4_autogen___1((&___ret__13s__anonymous4_1), ___src__13s__anonymous4_1));
+    return ((struct __anonymous4 )___ret__13s__anonymous4_1);
+}
 static inline void ___constructor__F_P13s__anonymous4i_autogen___1(struct __anonymous4 *___dst__P13s__anonymous4_1, int __i__i_1){
 …
+}
 static inline struct __anonymous5 ___operator_assign__F13s__anonymous5_P13s__anonymous513s__anonymous5_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, struct __anonymous5 ___src__13s__anonymous5_1){
+    struct __anonymous5 ___ret__13s__anonymous5_1;
     ((void)((*___dst__P13s__anonymous5_1).__i__i_1=___src__13s__anonymous5_1.__i__i_1));
+    return ((struct __anonymous5 )___src__13s__anonymous5_1);
+    ((void)___constructor__F_P13s__anonymous513s__anonymous5_autogen___1((&___ret__13s__anonymous5_1), ___src__13s__anonymous5_1));
+    return ((struct __anonymous5 )___ret__13s__anonymous5_1);
+}
 static inline void ___constructor__F_P13s__anonymous5i_autogen___1(struct __anonymous5 *___dst__P13s__anonymous5_1, int __i__i_1){
 …
+}
 static inline struct __anonymous6 ___operator_assign__F13s__anonymous6_P13s__anonymous613s__anonymous6_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, struct __anonymous6 ___src__13s__anonymous6_1){
+    struct __anonymous6 ___ret__13s__anonymous6_1;
     ((void)((*___dst__P13s__anonymous6_1).__i__i_1=___src__13s__anonymous6_1.__i__i_1));
+    return ((struct __anonymous6 )___src__13s__anonymous6_1);
+    ((void)___constructor__F_P13s__anonymous613s__anonymous6_autogen___1((&___ret__13s__anonymous6_1), ___src__13s__anonymous6_1));
+    return ((struct __anonymous6 )___ret__13s__anonymous6_1);
+}
 static inline void ___constructor__F_P13s__anonymous6i_autogen___1(struct __anonymous6 *___dst__P13s__anonymous6_1, int __i__i_1){
 …
+}
 static inline struct __anonymous7 ___operator_assign__F13s__anonymous7_P13s__anonymous713s__anonymous7_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, struct __anonymous7 ___src__13s__anonymous7_1){
+    struct __anonymous7 ___ret__13s__anonymous7_1;
     ((void)((*___dst__P13s__anonymous7_1).__i__i_1=___src__13s__anonymous7_1.__i__i_1));
+    return ((struct __anonymous7 )___src__13s__anonymous7_1);
+    ((void)___constructor__F_P13s__anonymous713s__anonymous7_autogen___1((&___ret__13s__anonymous7_1), ___src__13s__anonymous7_1));
+    return ((struct __anonymous7 )___ret__13s__anonymous7_1);
+}
 static inline void ___constructor__F_P13s__anonymous7i_autogen___1(struct __anonymous7 *___dst__P13s__anonymous7_1, int __i__i_1){
 …
+}
 static inline struct __anonymous8 ___operator_assign__F13s__anonymous8_P13s__anonymous813s__anonymous8_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, struct __anonymous8 ___src__13s__anonymous8_1){
+    struct __anonymous8 ___ret__13s__anonymous8_1;
     ((void)((*___dst__P13s__anonymous8_1).__i__s_1=___src__13s__anonymous8_1.__i__s_1));
+    return ((struct __anonymous8 )___src__13s__anonymous8_1);
+    ((void)___constructor__F_P13s__anonymous813s__anonymous8_autogen___1((&___ret__13s__anonymous8_1), ___src__13s__anonymous8_1));
+    return ((struct __anonymous8 )___ret__13s__anonymous8_1);
+}
 static inline void ___constructor__F_P13s__anonymous8s_autogen___1(struct __anonymous8 *___dst__P13s__anonymous8_1, short __i__s_1){
 …
+}
 static inline struct __anonymous9 ___operator_assign__F13s__anonymous9_P13s__anonymous913s__anonymous9_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, struct __anonymous9 ___src__13s__anonymous9_1){
+    struct __anonymous9 ___ret__13s__anonymous9_1;
     ((void)((*___dst__P13s__anonymous9_1).__i__s_1=___src__13s__anonymous9_1.__i__s_1));
+    return ((struct __anonymous9 )___src__13s__anonymous9_1);
+    ((void)___constructor__F_P13s__anonymous913s__anonymous9_autogen___1((&___ret__13s__anonymous9_1), ___src__13s__anonymous9_1));
+    return ((struct __anonymous9 )___ret__13s__anonymous9_1);
+}
 static inline void ___constructor__F_P13s__anonymous9s_autogen___1(struct __anonymous9 *___dst__P13s__anonymous9_1, short __i__s_1){
 …
+}
 static inline struct __anonymous10 ___operator_assign__F14s__anonymous10_P14s__anonymous1014s__anonymous10_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, struct __anonymous10 ___src__14s__anonymous10_1){
+    struct __anonymous10 ___ret__14s__anonymous10_1;
     ((void)((*___dst__P14s__anonymous10_1).__i__s_1=___src__14s__anonymous10_1.__i__s_1));
+    return ((struct __anonymous10 )___src__14s__anonymous10_1);
+    ((void)___constructor__F_P14s__anonymous1014s__anonymous10_autogen___1((&___ret__14s__anonymous10_1), ___src__14s__anonymous10_1));
+    return ((struct __anonymous10 )___ret__14s__anonymous10_1);
+}
 static inline void ___constructor__F_P14s__anonymous10s_autogen___1(struct __anonymous10 *___dst__P14s__anonymous10_1, short __i__s_1){
 …
+}
 static inline struct __anonymous11 ___operator_assign__F14s__anonymous11_P14s__anonymous1114s__anonymous11_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, struct __anonymous11 ___src__14s__anonymous11_1){
+    struct __anonymous11 ___ret__14s__anonymous11_1;
     ((void)((*___dst__P14s__anonymous11_1).__i__s_1=___src__14s__anonymous11_1.__i__s_1));
+    return ((struct __anonymous11 )___src__14s__anonymous11_1);
+    ((void)___constructor__F_P14s__anonymous1114s__anonymous11_autogen___1((&___ret__14s__anonymous11_1), ___src__14s__anonymous11_1));
+    return ((struct __anonymous11 )___ret__14s__anonymous11_1);
+}
 static inline void ___constructor__F_P14s__anonymous11s_autogen___1(struct __anonymous11 *___dst__P14s__anonymous11_1, short __i__s_1){
 …
+}
 static inline struct __anonymous12 ___operator_assign__F14s__anonymous12_P14s__anonymous1214s__anonymous12_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, struct __anonymous12 ___src__14s__anonymous12_1){
+    struct __anonymous12 ___ret__14s__anonymous12_1;
     ((void)((*___dst__P14s__anonymous12_1).__i__s_1=___src__14s__anonymous12_1.__i__s_1));
+    return ((struct __anonymous12 )___src__14s__anonymous12_1);
+    ((void)___constructor__F_P14s__anonymous1214s__anonymous12_autogen___1((&___ret__14s__anonymous12_1), ___src__14s__anonymous12_1));
+    return ((struct __anonymous12 )___ret__14s__anonymous12_1);
+}
 static inline void ___constructor__F_P14s__anonymous12s_autogen___1(struct __anonymous12 *___dst__P14s__anonymous12_1, short __i__s_1){
 …
+}
 static inline struct __anonymous13 ___operator_assign__F14s__anonymous13_P14s__anonymous1314s__anonymous13_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, struct __anonymous13 ___src__14s__anonymous13_1){
+    struct __anonymous13 ___ret__14s__anonymous13_1;
     ((void)((*___dst__P14s__anonymous13_1).__i__s_1=___src__14s__anonymous13_1.__i__s_1));
+    return ((struct __anonymous13 )___src__14s__anonymous13_1);
+    ((void)___constructor__F_P14s__anonymous1314s__anonymous13_autogen___1((&___ret__14s__anonymous13_1), ___src__14s__anonymous13_1));
+    return ((struct __anonymous13 )___ret__14s__anonymous13_1);
+}
 static inline void ___constructor__F_P14s__anonymous13s_autogen___1(struct __anonymous13 *___dst__P14s__anonymous13_1, short __i__s_1){
 …
+}
 static inline struct __anonymous14 ___operator_assign__F14s__anonymous14_P14s__anonymous1414s__anonymous14_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, struct __anonymous14 ___src__14s__anonymous14_1){
+    struct __anonymous14 ___ret__14s__anonymous14_1;
     ((void)((*___dst__P14s__anonymous14_1).__i__s_1=___src__14s__anonymous14_1.__i__s_1));
+    return ((struct __anonymous14 )___src__14s__anonymous14_1);
+    ((void)___constructor__F_P14s__anonymous1414s__anonymous14_autogen___1((&___ret__14s__anonymous14_1), ___src__14s__anonymous14_1));
+    return ((struct __anonymous14 )___ret__14s__anonymous14_1);
+}
 static inline void ___constructor__F_P14s__anonymous14s_autogen___1(struct __anonymous14 *___dst__P14s__anonymous14_1, short __i__s_1){
 …
+}
 static inline struct __anonymous15 ___operator_assign__F14s__anonymous15_P14s__anonymous1514s__anonymous15_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, struct __anonymous15 ___src__14s__anonymous15_1){
+    struct __anonymous15 ___ret__14s__anonymous15_1;
     ((void)((*___dst__P14s__anonymous15_1).__i__s_1=___src__14s__anonymous15_1.__i__s_1));
+    return ((struct __anonymous15 )___src__14s__anonymous15_1);
+    ((void)___constructor__F_P14s__anonymous1514s__anonymous15_autogen___1((&___ret__14s__anonymous15_1), ___src__14s__anonymous15_1));
+    return ((struct __anonymous15 )___ret__14s__anonymous15_1);
+}
 static inline void ___constructor__F_P14s__anonymous15s_autogen___1(struct __anonymous15 *___dst__P14s__anonymous15_1, short __i__s_1){
 …
+}
 static inline struct __anonymous16 ___operator_assign__F14s__anonymous16_P14s__anonymous1614s__anonymous16_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, struct __anonymous16 ___src__14s__anonymous16_1){
+    struct __anonymous16 ___ret__14s__anonymous16_1;
     ((void)((*___dst__P14s__anonymous16_1).__i__i_1=___src__14s__anonymous16_1.__i__i_1));
+    return ((struct __anonymous16 )___src__14s__anonymous16_1);
+    ((void)___constructor__F_P14s__anonymous1614s__anonymous16_autogen___1((&___ret__14s__anonymous16_1), ___src__14s__anonymous16_1));
+    return ((struct __anonymous16 )___ret__14s__anonymous16_1);
+}
 static inline void ___constructor__F_P14s__anonymous16i_autogen___1(struct __anonymous16 *___dst__P14s__anonymous16_1, int __i__i_1){
 …
+}
 static inline struct __anonymous17 ___operator_assign__F14s__anonymous17_P14s__anonymous1714s__anonymous17_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, struct __anonymous17 ___src__14s__anonymous17_1){
+    struct __anonymous17 ___ret__14s__anonymous17_1;
     ((void)((*___dst__P14s__anonymous17_1).__i__i_1=___src__14s__anonymous17_1.__i__i_1));
+    return ((struct __anonymous17 )___src__14s__anonymous17_1);
+    ((void)___constructor__F_P14s__anonymous1714s__anonymous17_autogen___1((&___ret__14s__anonymous17_1), ___src__14s__anonymous17_1));
+    return ((struct __anonymous17 )___ret__14s__anonymous17_1);
+}
 static inline void ___constructor__F_P14s__anonymous17i_autogen___1(struct __anonymous17 *___dst__P14s__anonymous17_1, int __i__i_1){
 …
+}
 static inline struct __anonymous18 ___operator_assign__F14s__anonymous18_P14s__anonymous1814s__anonymous18_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, struct __anonymous18 ___src__14s__anonymous18_1){
+    struct __anonymous18 ___ret__14s__anonymous18_1;
     ((void)((*___dst__P14s__anonymous18_1).__i__i_1=___src__14s__anonymous18_1.__i__i_1));
+    return ((struct __anonymous18 )___src__14s__anonymous18_1);
+    ((void)___constructor__F_P14s__anonymous1814s__anonymous18_autogen___1((&___ret__14s__anonymous18_1), ___src__14s__anonymous18_1));
+    return ((struct __anonymous18 )___ret__14s__anonymous18_1);
+}
 static inline void ___constructor__F_P14s__anonymous18i_autogen___1(struct __anonymous18 *___dst__P14s__anonymous18_1, int __i__i_1){
 …
+}
 static inline struct __anonymous19 ___operator_assign__F14s__anonymous19_P14s__anonymous1914s__anonymous19_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, struct __anonymous19 ___src__14s__anonymous19_1){
+    struct __anonymous19 ___ret__14s__anonymous19_1;
     ((void)((*___dst__P14s__anonymous19_1).__i__i_1=___src__14s__anonymous19_1.__i__i_1));
+    return ((struct __anonymous19 )___src__14s__anonymous19_1);
+    ((void)___constructor__F_P14s__anonymous1914s__anonymous19_autogen___1((&___ret__14s__anonymous19_1), ___src__14s__anonymous19_1));
+    return ((struct __anonymous19 )___ret__14s__anonymous19_1);
+}
 static inline void ___constructor__F_P14s__anonymous19i_autogen___1(struct __anonymous19 *___dst__P14s__anonymous19_1, int __i__i_1){
 …
+}
 static inline struct __anonymous20 ___operator_assign__F14s__anonymous20_P14s__anonymous2014s__anonymous20_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, struct __anonymous20 ___src__14s__anonymous20_1){
+    struct __anonymous20 ___ret__14s__anonymous20_1;
     ((void)((*___dst__P14s__anonymous20_1).__i__i_1=___src__14s__anonymous20_1.__i__i_1));
+    return ((struct __anonymous20 )___src__14s__anonymous20_1);
+    ((void)___constructor__F_P14s__anonymous2014s__anonymous20_autogen___1((&___ret__14s__anonymous20_1), ___src__14s__anonymous20_1));
+    return ((struct __anonymous20 )___ret__14s__anonymous20_1);
+}
 static inline void ___constructor__F_P14s__anonymous20i_autogen___1(struct __anonymous20 *___dst__P14s__anonymous20_1, int __i__i_1){
 …
+}
 static inline struct __anonymous21 ___operator_assign__F14s__anonymous21_P14s__anonymous2114s__anonymous21_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, struct __anonymous21 ___src__14s__anonymous21_1){
+    struct __anonymous21 ___ret__14s__anonymous21_1;
     ((void)((*___dst__P14s__anonymous21_1).__i__i_1=___src__14s__anonymous21_1.__i__i_1));
+    return ((struct __anonymous21 )___src__14s__anonymous21_1);
+    ((void)___constructor__F_P14s__anonymous2114s__anonymous21_autogen___1((&___ret__14s__anonymous21_1), ___src__14s__anonymous21_1));
+    return ((struct __anonymous21 )___ret__14s__anonymous21_1);
+}
 static inline void ___constructor__F_P14s__anonymous21i_autogen___1(struct __anonymous21 *___dst__P14s__anonymous21_1, int __i__i_1){
 …
+}
 static inline struct __anonymous22 ___operator_assign__F14s__anonymous22_P14s__anonymous2214s__anonymous22_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, struct __anonymous22 ___src__14s__anonymous22_1){
+    struct __anonymous22 ___ret__14s__anonymous22_1;
     ((void)((*___dst__P14s__anonymous22_1).__i__i_1=___src__14s__anonymous22_1.__i__i_1));
+    return ((struct __anonymous22 )___src__14s__anonymous22_1);
+    ((void)___constructor__F_P14s__anonymous2214s__anonymous22_autogen___1((&___ret__14s__anonymous22_1), ___src__14s__anonymous22_1));
+    return ((struct __anonymous22 )___ret__14s__anonymous22_1);
+}
 static inline void ___constructor__F_P14s__anonymous22i_autogen___1(struct __anonymous22 *___dst__P14s__anonymous22_1, int __i__i_1){
 …
+}
 static inline struct __anonymous23 ___operator_assign__F14s__anonymous23_P14s__anonymous2314s__anonymous23_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, struct __anonymous23 ___src__14s__anonymous23_1){
+    struct __anonymous23 ___ret__14s__anonymous23_1;
     ((void)((*___dst__P14s__anonymous23_1).__i__i_1=___src__14s__anonymous23_1.__i__i_1));
+    return ((struct __anonymous23 )___src__14s__anonymous23_1);
+    ((void)___constructor__F_P14s__anonymous2314s__anonymous23_autogen___1((&___ret__14s__anonymous23_1), ___src__14s__anonymous23_1));
+    return ((struct __anonymous23 )___ret__14s__anonymous23_1);
+}
 static inline void ___constructor__F_P14s__anonymous23i_autogen___1(struct __anonymous23 *___dst__P14s__anonymous23_1, int __i__i_1){

src/tests/.expect/64/extension.txt

-              r6ac2ada
+              r1ed33fed
+}
 static inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___1(struct S *___dst__P2sS_1, struct S ___src__2sS_1){
+    struct S ___ret__2sS_1;
     ((void)((*___dst__P2sS_1).__a__i_1=___src__2sS_1.__a__i_1));
     ((void)((*___dst__P2sS_1).__b__i_1=___src__2sS_1.__b__i_1));
     ((void)((*___dst__P2sS_1).__c__i_1=___src__2sS_1.__c__i_1));
+    return ((struct S )___src__2sS_1);
+    ((void)___constructor__F_P2sS2sS_autogen___1((&___ret__2sS_1), ___src__2sS_1));
+    return ((struct S )___ret__2sS_1);
+}
 static inline void ___constructor__F_P2sSi_autogen___1(struct S *___dst__P2sS_1, int __a__i_1){
 …
+}
 static inline union U ___operator_assign__F2uU_P2uU2uU_autogen___1(union U *___dst__P2uU_1, union U ___src__2uU_1){
+    union U ___ret__2uU_1;
     ((void)__builtin_memcpy(((void *)___dst__P2uU_1), ((const void *)(&___src__2uU_1)), sizeof(union U )));
+    return ((union U )___src__2uU_1);
+    ((void)___constructor__F_P2uU2uU_autogen___1((&___ret__2uU_1), ___src__2uU_1));
+    return ((union U )___ret__2uU_1);
+}
 static inline void ___constructor__F_P2uUi_autogen___1(union U *___dst__P2uU_1, int __src__i_1){

src/tests/.expect/64/gccExtensions.txt

-              r6ac2ada
+              r1ed33fed
+    }
     inline struct S ___operator_assign__F2sS_P2sS2sS_autogen___2(struct S *___dst__P2sS_2, struct S ___src__2sS_2){
+        struct S ___ret__2sS_2;
         ((void)((*___dst__P2sS_2).__a__i_2=___src__2sS_2.__a__i_2));
         ((void)((*___dst__P2sS_2).__b__i_2=___src__2sS_2.__b__i_2));
         ((void)((*___dst__P2sS_2).__c__i_2=___src__2sS_2.__c__i_2));
+        return ((struct S )___src__2sS_2);
+        ((void)___constructor__F_P2sS2sS_autogen___2((&___ret__2sS_2), ___src__2sS_2));
+        return ((struct S )___ret__2sS_2);
+    }
     inline void ___constructor__F_P2sSi_autogen___2(struct S *___dst__P2sS_2, int __a__i_2){
 …
+    }
     inline struct s2 ___operator_assign__F3ss2_P3ss23ss2_autogen___2(struct s2 *___dst__P3ss2_2, struct s2 ___src__3ss2_2){
+        struct s2 ___ret__3ss2_2;
         ((void)((*___dst__P3ss2_2).__i__i_2=___src__3ss2_2.__i__i_2));
+        return ((struct s2 )___src__3ss2_2);
+        ((void)___constructor__F_P3ss23ss2_autogen___2((&___ret__3ss2_2), ___src__3ss2_2));
+        return ((struct s2 )___ret__3ss2_2);
+    }
     inline void ___constructor__F_P3ss2i_autogen___2(struct s2 *___dst__P3ss2_2, int __i__i_2){
 …
+    }
     inline struct s3 ___operator_assign__F3ss3_P3ss33ss3_autogen___2(struct s3 *___dst__P3ss3_2, struct s3 ___src__3ss3_2){
+        struct s3 ___ret__3ss3_2;
         ((void)((*___dst__P3ss3_2).__i__i_2=___src__3ss3_2.__i__i_2));
+        return ((struct s3 )___src__3ss3_2);
+        ((void)___constructor__F_P3ss33ss3_autogen___2((&___ret__3ss3_2), ___src__3ss3_2));
+        return ((struct s3 )___ret__3ss3_2);
+    }
     inline void ___constructor__F_P3ss3i_autogen___2(struct s3 *___dst__P3ss3_2, int __i__i_2){
 …
+    }
     inline struct s4 ___operator_assign__F3ss4_P3ss43ss4_autogen___2(struct s4 *___dst__P3ss4_2, struct s4 ___src__3ss4_2){
+        struct s4 ___ret__3ss4_2;
         ((void)((*___dst__P3ss4_2).__i__i_2=___src__3ss4_2.__i__i_2));
+        return ((struct s4 )___src__3ss4_2);
+        ((void)___constructor__F_P3ss43ss4_autogen___2((&___ret__3ss4_2), ___src__3ss4_2));
+        return ((struct s4 )___ret__3ss4_2);
+    }
     inline void ___constructor__F_P3ss4i_autogen___2(struct s4 *___dst__P3ss4_2, int __i__i_2){

src/tests/.expect/memberCtors-ERR1.txt

r6ac2ada	r1ed33fed
1		memberCtors.c:62 error: in void ?{}(B *b), field a2 used before being constructed
	1	memberCtors.c:71 error: in void ?{}(B *b), field a2 used before being constructed

src/tests/.expect/memberCtors.txt

-              r6ac2ada
+              r1ed33fed
 assigning int: 0 0
 end construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 1001
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+begin ?=? A
+copy constructing int: 1001
+destructing int: 1001
+destructing int: 1001
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end ?=? A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 1001
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+destructing int: 0
+destructing int: 0
+destructing int: 1001
+destructing int: 0
+destructing int: 0
+destructing int: 1001
 construct b->a1
 constructing int
 …
 copy constructing int: 1000
 assign this->y
+end copy construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 1001
+assign this->y
+end copy construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 0
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 1001
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 0
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
 end copy construct A
 End of main
 …
 assigning int: 0 0
 end construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 999
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+begin ?=? A
+copy constructing int: 999
+destructing int: 999
+destructing int: 999
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end ?=? A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 999
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+destructing int: 0
+destructing int: 0
+destructing int: 999
+destructing int: 0
+destructing int: 0
+destructing int: 999
 destructing int: 0
 destructing int: 0
 …
 assigning int: 0 0
 end construct A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 999
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+begin ?=? A
+copy constructing int: 999
+destructing int: 999
+destructing int: 999
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end ?=? A
+copy constructing int: 0
+copy constructing int: 0
+begin copy construct A
+copy construct this->x
+copy constructing int: 999
+assign this->y
+copy constructing int: 0
+destructing int: 0
+destructing int: 0
+end copy construct A
+destructing int: 0
+destructing int: 0
+destructing int: 999
+destructing int: 0
+destructing int: 0
+destructing int: 999
 destructing int: 0
 destructing int: 0

src/tests/Makefile.am

-              r6ac2ada
+              r1ed33fed
 debug=yes
 quick_test=vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once
+quick_test=vector_test avl_test operators numericConstants expression enum array typeof cast dtor-early-exit init_once attributes
 if BUILD_CONCURRENCY
 …
 # applies to both programs
 EXTRA_FLAGS =
 BUILD_FLAGS = -g -Wall -Wno-unused-function @CFA_FLAGS@ ${EXTRA_FLAGS}
+BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ ${EXTRA_FLAGS}
 TEST_FLAGS = $(if $(test), 2> .err/${@}.log, )
 CFLAGS = ${TEST_FLAGS} ${BUILD_FLAGS}
 …
 declarationSpecifier: declarationSpecifier.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gccExtensions : gccExtensions.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 extension : extension.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 attributes : attributes.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 KRfunctions : KRfunctions.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 memberCtors-ERR1: memberCtors.c

src/tests/Makefile.in

-              r6ac2ada
+              r1ed33fed
 quick_test = vector_test avl_test operators numericConstants \
         expression enum array typeof cast dtor-early-exit init_once \
         $(am__append_1)
+        attributes $(am__append_1)
 @BUILD_CONCURRENCY_FALSE@concurrent = no
 @BUILD_CONCURRENCY_TRUE@concurrent = yes
 …
 # applies to both programs
 EXTRA_FLAGS =
 BUILD_FLAGS = -g -Wall -Wno-unused-function @CFA_FLAGS@ ${EXTRA_FLAGS}
+BUILD_FLAGS = -g -Wall -Wno-unused-function -quiet @CFA_FLAGS@ ${EXTRA_FLAGS}
 TEST_FLAGS = $(if $(test), 2> .err/${@}.log, )
 fstream_test_SOURCES = fstream_test.c
 …
 declarationSpecifier: declarationSpecifier.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 gccExtensions : gccExtensions.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 extension : extension.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 attributes : attributes.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 KRfunctions : KRfunctions.c
         ${CC} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
+        ${CC} ${CFLAGS} -CFA -XCFA -p -XCFA -L ${<} -o ${@}
 memberCtors-ERR1: memberCtors.c

src/tests/memberCtors.c

-              r6ac2ada
+              r1ed33fed
 } // z never constructed - will be automatically copy constructed
+A ?=?(A * this, A other) {
+  printf("begin ?=? A\n");
+  this->x = other.x;
+  this->y = other.y;
+  this->z = other.z;
+  printf("end ?=? A\n");
+  return *this;
+}
 struct B {
   A a1, a2, a3;

src/tests/sched-int-wait.c

-              r6ac2ada
+              r1ed33fed
 #include <stdlib>
 #include <thread>
+static const int N = 10_000;
 monitor global_t {};
 …
 condition condAB, condAC, condBC, condABC;
+thread Signaler {
+        int signals[4];
+};
+void ?{}( Signaler * this ){
+        this->signals[0] = 0;
+        this->signals[1] = 0;
+        this->signals[2] = 0;
+        this->signals[3] = 0;
+}
+thread Signaler {};
 thread WaiterAB {};
 thread WaiterAC {};
 …
 thread WaiterABC{};
 volatile bool done;
+volatile int waiter_left;
 //----------------------------------------------------------------------------------------------------
 …
 void main( Signaler* this ) {
+        while( true ) {
+                int action = (unsigned)rand48() % 4;
+                bool finished = true;
+                for(int i = 0; i < 4; i++) {
+                        if( this->signals[action] < 10_000 ) {
+                                finished = false;
+                                break;
+                        }
+                        else {
+                                action = (action + 1) % 4;
+                        }
+                }
+                this->signals[action]++;
+                if( finished ) break;
+                //sout | action | this->signals[0] | this->signals[1] | this->signals[2] | this->signals[3] | endl;
+        while( waiter_left != 0 ) {
+                unsigned action = (unsigned)rand48() % 4;
                 switch( action ) {
                         case 0:
 …
                                 abort();
+                }
+                yield();
+        }
+}
 …
 // Waiter ABC
 void main( WaiterABC* this ) {
         while( !done ) {
+        for( int i = 0; i < N; i++ ) {
                 wait( &condABC, &globalA, &globalB, &globalC );
+        }
+        __sync_fetch_and_sub_4( &waiter_left, 1);
+}
 …
 // Waiter AB
 void main( WaiterAB* this ) {
         while( !done ) {
+        for( int i = 0; i < N; i++ ) {
                 wait( &condAB , &globalA, &globalB );
+        }
+        __sync_fetch_and_sub_4( &waiter_left, 1);
+}
 …
 // Waiter AC
 void main( WaiterAC* this ) {
         while( !done ) {
+        for( int i = 0; i < N; i++ ) {
                 wait( &condAC , &globalA, &globalC );
+        }
+        __sync_fetch_and_sub_4( &waiter_left, 1);
+}
 …
 // Waiter BC
 void main( WaiterBC* this ) {
         while( !done ) {
+        for( int i = 0; i < N; i++ ) {
                 wait( &condBC , &globalB, &globalC );
+        }
+        __sync_fetch_and_sub_4( &waiter_left, 1);
+}
 …
 // Main
 int main(int argc, char* argv[]) {
         done = false;
+        waiter_left = 4;
         processor p;
+        {
+                WaiterABC a;
+                WaiterAB  b;
+                WaiterBC  c;
+                WaiterAC  d;
+                Signaler  e;
+                {
+                        Signaler  e;
+                        WaiterABC a;
+                        WaiterAB  b;
+                        WaiterBC  c;
+                        WaiterAC  d;
+                }
-                done = true;
-                signal( &condABC, &globalA, &globalB, &globalC );
-                signal( &condAB , &globalA, &globalB );
-                signal( &condBC , &globalB, &globalC );
-                signal( &condAC , &globalA, &globalC );
+        }
+}

src/tests/test.py

-              r6ac2ada
+              r1ed33fed
         sh('echo "void ?{}(int*a,int b){}int main(){return 0;}" > .dummy.c')
         ret, out = sh("make .dummy -s", print2stdout=True)
         if ret != 0:
                 print("Failed to identify architecture:")
 …
         # build, skipping to next test on error
         make_ret, _ = sh("""%s test=yes EXTRA_FLAGS="-quiet %s" %s 2> %s 1> /dev/null""" % (make_cmd, options, test.name, out_file), dry_run)
+        make_ret, _ = sh("""%s test=yes EXTRA_FLAGS="%s" %s 2> %s 1> /dev/null""" % (make_cmd, options, test.name, out_file), dry_run)
         # if the make command succeds continue otherwise skip to diff
 …
                 # fetch return code and error from the diff command
                 retcode, error = diff(".expect/%s.txt" % test.path, ".out/%s.log" % test.name, dry_run)
         # clean the executable
         sh("rm -f %s > /dev/null 2>&1" % test.name, dry_run)
 …
 if __name__ == "__main__":
         #always run from same folder
         chdir()
+        chdir()
         # parse the command line arguments
         options = getOptions()

Context Navigation

Legend:

Jenkinsfile

doc/LaTeXmacros/common.tex

doc/proposals/concurrency/Makefile

doc/proposals/concurrency/concurrency.tex

doc/proposals/concurrency/style.tex

doc/proposals/concurrency/version

src/CodeGen/CodeGenerator.cc

src/CodeGen/CodeGenerator.h

src/CodeGen/GenType.cc

src/CodeGen/GenType.h

src/CodeGen/Generate.cc

src/CodeGen/Generate.h

src/Common/utility.h

src/GenPoly/Box.cc

src/InitTweak/FixInit.cc

src/InitTweak/GenInit.cc

src/main.cc

src/prelude/Makefile.am

src/prelude/Makefile.in

src/tests/.expect/32/KRfunctions.txt

src/tests/.expect/32/attributes.txt

src/tests/.expect/32/declarationSpecifier.txt

src/tests/.expect/32/extension.txt

src/tests/.expect/32/gccExtensions.txt

src/tests/.expect/64/KRfunctions.txt

src/tests/.expect/64/attributes.txt

src/tests/.expect/64/declarationSpecifier.txt

src/tests/.expect/64/extension.txt

src/tests/.expect/64/gccExtensions.txt

src/tests/.expect/memberCtors-ERR1.txt

src/tests/.expect/memberCtors.txt

src/tests/Makefile.am

src/tests/Makefile.in

src/tests/memberCtors.c

src/tests/sched-int-wait.c

src/tests/test.py

Download in other formats: