Index: doc/proposals/concurrency/Makefile =================================================================== --- doc/proposals/concurrency/Makefile (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/Makefile (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -17,4 +17,6 @@ text/concurrency \ text/parallelism \ +text/together \ +text/future \ } Index: doc/proposals/concurrency/annex/glossary.tex =================================================================== --- doc/proposals/concurrency/annex/glossary.tex (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/annex/glossary.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -101,2 +101,3 @@ \newacronym{api}{API}{Application Program Interface} \newacronym{raii}{RAII}{Ressource Acquisition Is Initialization} +\newacronym{numa}{NUMA}{Non-Uniform Memory Access} Index: doc/proposals/concurrency/text/cforall.tex =================================================================== --- doc/proposals/concurrency/text/cforall.tex (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/text/cforall.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -15,17 +15,17 @@ int x, *p1 = &x, **p2 = &p1, ***p3 = &p2, &r1 = x, &&r2 = r1, &&&r3 = r2; -***p3 = 3; // change x -r3 = 3; // change x, ***r3 -**p3 = ...; // change p1 -&r3 = ...; // change r1, (&*)**r3 -*p3 = ...; // change p2 -&&r3 = ...; // change r2, (&(&*)*)*r3 -&&&r3 = p3; // change r3 to p3, (&(&(&*)*)*)r3 -int y, z, & ar[3] = { x, y, z }; // initialize array of references -&ar[1] = &z; // change reference array element -typeof( ar[1] ) p; // is int, i.e., the type of referenced object -typeof( &ar[1] ) q; // is int &, i.e., the type of reference -sizeof( ar[1] ) == sizeof( int ); // is true, i.e., the size of referenced object -sizeof( &ar[1] ) == sizeof( int *); // is true, i.e., the size of a reference +***p3 = 3; // change x +r3 = 3; // change x, ***r3 +**p3 = ...; // change p1 +&r3 = ...; // change r1, (&*)**r3 +*p3 = ...; // change p2 +&&r3 = ...; // change r2, (&(&*)*)*r3 +&&&r3 = p3; // change r3 to p3, (&(&(&*)*)*)r3 +int y, z, & ar[3] = { x, y, z }; // initialize array of references +&ar[1] = &z; // change reference array element +typeof( ar[1] ) p; // is int, i.e., the type of referenced object +typeof( &ar[1] ) q; // is int &, i.e., the type of reference +sizeof( ar[1] ) == sizeof( int ); // is true, i.e., the size of referenced object +sizeof( &ar[1] ) == sizeof( int *); // is true, i.e., the size of a reference \end{cfacode} The important thing to take away from this code snippet is that references offer a handle to an object much like pointers but which is automatically derefferenced when convinient. @@ -36,18 +36,18 @@ \begin{cfacode} // selection based on type and number of parameters -void f( void ); // (1) -void f( char ); // (2) -void f( int, double ); // (3) -f(); // select (1) -f( 'a' ); // select (2) -f( 3, 5.2 ); // select (3) +void f( void ); // (1) +void f( char ); // (2) +void f( int, double ); // (3) +f(); // select (1) +f( 'a' ); // select (2) +f( 3, 5.2 ); // select (3) // selection based on type and number of returns -char f( int ); // (1) -double f( int ); // (2) -[ int, double ] f( int ); // (3) -char c = f( 3 ); // select (1) -double d = f( 4 ); // select (2) -[ int, double ] t = f( 5 ); // select (3) +char f( int ); // (1) +double f( int ); // (2) +[ int, double ] f( int ); // (3) +char c = f( 3 ); // select (1) +double d = f( 4 ); // select (2) +[ int, double ] t = f( 5 ); // select (3) \end{cfacode} This feature is particularly important for concurrency since the runtime system relies on creating different types do represent concurrency objects. Therefore, overloading is necessary to prevent the need for long prefixes and other naming conventions that prevent clashes. As seen in chapter \ref{basics}, the main is an example of routine that benefits from overloading when concurrency in introduced. @@ -56,17 +56,17 @@ Overloading also extends to operators. The syntax for denoting operator-overloading is to name a routine with the symbol of the operator and question marks where the arguments of the operation would be, like so : \begin{cfacode} -int ++?( int op ); // unary prefix increment -int ?++( int op ); // unary postfix increment -int ?+?( int op1, int op2 ); // binary plus -int ?<=?( int op1, int op2 ); // binary less than -int ?=?( int & op1, int op2 ); // binary assignment -int ?+=?( int & op1, int op2 ); // binary plus-assignment +int ++?( int op ); // unary prefix increment +int ?++( int op ); // unary postfix increment +int ?+?( int op1, int op2 ); // binary plus +int ?<=?( int op1, int op2 ); // binary less than +int ?=?( int & op1, int op2 ); // binary assignment +int ?+=?( int & op1, int op2 ); // binary plus-assignment struct S { int i, j; }; -S ?+?( S op1, S op2 ) { // add two structures +S ?+?( S op1, S op2 ) { // add two structures return (S){ op1.i + op2.i, op1.j + op2.j }; } S s1 = { 1, 2 }, s2 = { 2, 3 }, s3; -s3 = s1 + s2; // compute sum: s3 == { 2, 5 } +s3 = s1 + s2; // compute sum: s3 == { 2, 5 } \end{cfacode} @@ -74,5 +74,5 @@ \section{Constructors/Destructors} -\CFA uses the following syntax for constructors and destructors : +Object life time is often a challenge in concurrency. \CFA uses the approach of giving concurrent meaning to object life time as a mean of synchronization and/or mutual exclusion. Since \CFA relies heavily on the life time of objects, Constructors \& Destructors are a the core of the features required for concurrency and parallelism. \CFA uses the following syntax for constructors and destructors : \begin{cfacode} struct S { @@ -80,18 +80,18 @@ int * ia; }; -void ?{}( S & s, int asize ) with s { // constructor operator - size = asize; // initialize fields +void ?{}( S & s, int asize ) with s { // constructor operator + size = asize; // initialize fields ia = calloc( size, sizeof( S ) ); } -void ^?{}( S & s ) with s { // destructor operator - free( ia ); // de-initialization fields +void ^?{}( S & s ) with s { // destructor operator + free( ia ); // de-initialization fields } int main() { - S x = { 10 }, y = { 100 }; // implict calls: ?{}( x, 10 ), ?{}( y, 100 ) - ... // use x and y - ^x{}; ^y{}; // explicit calls to de-initialize - x{ 20 }; y{ 200 }; // explicit calls to reinitialize - ... // reuse x and y -} // implict calls: ^?{}( y ), ^?{}( x ) + S x = { 10 }, y = { 100 }; // implict calls: ?{}( x, 10 ), ?{}( y, 100 ) + ... // use x and y + ^x{}; ^y{}; // explicit calls to de-initialize + x{ 20 }; y{ 200 }; // explicit calls to reinitialize + ... // reuse x and y +} // implict calls: ^?{}( y ), ^?{}( x ) \end{cfacode} The language guarantees that every object and all their fields are constructed. Like \CC construction is automatically done on declaration and destruction done when the declared variables reach the end of its scope. Index: doc/proposals/concurrency/text/concurrency.tex =================================================================== --- doc/proposals/concurrency/text/concurrency.tex (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/text/concurrency.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -69,5 +69,5 @@ int f5(graph(monitor*) & mutex m); \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 objects are only acquired once becomes 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. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. 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: +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 objects are only acquired once becomes none-trivial. This can be extended to absurd limits like \code{f5}, which uses a graph of monitors. To make the issue tractable, 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. This is specially true for non-copyable objects like monitors, where an array of pointers is simplest way to express a group of monitors. 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: \begin{cfacode} @@ -608,5 +608,5 @@ % ====================================================================== % ====================================================================== -There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system. +There are several challenges specific to \CFA when implementing internal scheduling. These challenges are direct results of \gls{group-acquire} and loose object definitions. These two constraints are to root cause of most design decisions in the implementation of internal scheduling. Furthermore, to avoid the head-aches of dynamically allocating memory in a concurrent environment, the internal-scheduling design is entirely free of mallocs and other dynamic memory allocation scheme. This is to avoid the chicken and egg problem \cite{Chicken} of having a memory allocator that relies on the threading system and a threading system that relies on the runtime. This extra goal, means that memory management is a constant concern in the design of the system. The main memory concern for concurrency is queues. All blocking operations are made by parking threads onto queues. These queues need to be intrinsic\cit to avoid the need memory allocation. This entails that all the fields needed to keep track of all needed information. Since internal scheduling can use an unbound amount of memory (depending on \gls{group-acquire}) statically defining information information in the intrusive fields of threads is insufficient. The only variable sized container that does not require memory allocation is the callstack, which is heavily used in the implementation of internal scheduling. Particularly the GCC extension variable length arrays which is used extensively. @@ -832,8 +832,5 @@ 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 reasonable 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. -% ====================================================================== -% ====================================================================== -\section{Other concurrency tools} -% ====================================================================== -% ====================================================================== -% \TODO + +\subsection{Internals} +The complete mask can be pushed to any one, we are in a context where we already have full ownership of (at least) every concerned monitor and therefore monitors will refuse all calls no matter what. Index: doc/proposals/concurrency/text/future.tex =================================================================== --- doc/proposals/concurrency/text/future.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) +++ doc/proposals/concurrency/text/future.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -0,0 +1,86 @@ +% ====================================================================== +% ====================================================================== +\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. +\section{Non-Blocking IO} + + +\section{Other concurrency tools} + + +\section{Implicit threading} +% Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level. +% +% \begin{center} +% \begin{tabular}[t]{|c|c|c|} +% Sequential & System Parallel & Language Parallel \\ +% \begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% for(int i = 0; i < length; ++i ) { +% out[i] = a[i] + b[i]; +% } +% } +% +% +% +% +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting} &\begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% range ar(a, a + length); +% range br(b, b + length); +% range or(out, out + length); +% parfor( ai, bi, oi, +% [](int* ai, int* bi, int* oi) { +% oi = ai + bi; +% }); +% } +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting}&\begin{lstlisting} +% void big_sum(int* a, int* b, +% int* out, +% size_t length) +% { +% for (ai, bi, oi) in (a, b, out) { +% oi = ai + bi; +% } +% } +% +% +% +% +% +% int* a[10000]; +% int* b[10000]; +% int* c[10000]; +% //... fill in a and b ... +% big_sum(a, b, c, 10000); +% \end{lstlisting} +% \end{tabular} +% \end{center} +% + + +\section{Multiple Paradigms} + + +\section{Transactions} Index: doc/proposals/concurrency/text/intro.tex =================================================================== --- doc/proposals/concurrency/text/intro.tex (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/text/intro.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -3,5 +3,5 @@ % ====================================================================== -This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system 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. Therefore a high-level approach is adapted in \CFA +This proposal provides a minimal concurrency API that is simple, efficient and can be reused to build higher-level features. The simplest possible concurrency system 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 concurrent programming, high-level approaches are much more popular~\cite{HPP:Study}. Examples are task based, message passing and implicit threading. Therefore a high-level approach is adopted in \CFA -There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the users. While these two concepts are often combined, they are in fact distinct concepts that require different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization. +There are actually two problems that need to be solved in the design of concurrency for a programming language: which concurrency and which parallelism tools are available to the programmers. While these two concepts are often combined, they are in fact distinct, requiring different tools~\cite{Buhr05a}. Concurrency tools need to handle mutual exclusion and synchronization, while parallelism tools are about performance, cost and resource utilization. Index: doc/proposals/concurrency/text/parallelism.tex =================================================================== --- doc/proposals/concurrency/text/parallelism.tex (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/text/parallelism.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -11,107 +11,29 @@ \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. +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 expensive costs of 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}. \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. +A popular varient of \glspl{uthread} is what is often refered 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. An example of a language that uses fibers is Go~\cite{Go} \subsection{Jobs and thread pools} -The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores. +The approach on the opposite end of the spectrum is to base parallelism on \glspl{pool}. Indeed, \glspl{pool} offer limited flexibility but at the benefit of a simpler user interface. In \gls{pool} based systems, users express parallelism as units of work, called jobs, and a dependency graph (either explicit or implicit) that tie them together. This approach means users need not worry about concurrency but significantly limits the interaction that can occur among jobs. Indeed, any \gls{job} that blocks also blocks the underlying worker, which effectively means the CPU utilization, and therefore throughput, suffers noticeably. It can be argued that a solution to this problem is to use more workers than available cores. However, unless the number of jobs and the number of workers are comparable, having a significant amount of blocked jobs always results in idles cores. The gold standard of this implementation is Intel's TBB library~\cite{TBB}. \subsection{Paradigm performance} -While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead. However, interactions between jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches will be more expansive and the extra control means users need to tweak more variables to get the desired performance. Furthermore, if the units of uninterrupted work are large enough the paradigm choice is largely amorticised by the actual work done. +While the choice between the three paradigms listed above may have significant performance implication, it is difficult to pindown the performance implications of chosing a model at the language level. Indeed, in many situations one of these paradigms may show better performance but it all strongly depends on the workload. Having a large amount of mostly independent units of work to execute almost guarantess that the \gls{pool} based system has the best performance thanks to the lower memory overhead (i.e., not thread stack per job). However, interactions among jobs can easily exacerbate contention. User-level threads allow fine-grain context switching, which results in better resource utilisation, but context switches is more expansive and the extra control means users need to tweak more variables to get the desired performance. Finally, if the units of uninterrupted work are large enough the paradigm choice is largely amortised by the actual work done. -\newpage \TODO -\subsection{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel} + +\section{The \protect\CFA\ Kernel : Processors, Clusters and Threads}\label{kernel} +\subsubsection{Future Work: Machine setup}\label{machine} +While this was not done in the context of this proposal, another important aspect of clusters is affinity. While many common desktop and laptop PCs have homogeneous CPUs, other devices often have more heteregenous setups. For example, system using \acrshort{numa} configurations may benefit from users being able to tie clusters and/or kernel threads to certains CPU cores. OS support for CPU affinity is now common \cit, which means it is both possible and desirable for \CFA to offer an abstraction mechanism for portable CPU affinity. + \subsection{Paradigms}\label{cfaparadigms} -Given these building blocks we can then reproduce the all three of the popular paradigms. Indeed, we get \glspl{uthread} as the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. - -% \subsection{High-level options}\label{tasks} -% -% \subsubsection{Thread interface} -% constructors destructors -% initializer lists -% monitors -% -% \subsubsection{Futures} -% -% \subsubsection{Implicit threading} -% Finally, simpler applications can benefit greatly from having implicit parallelism. That is, parallelism that does not rely on the user to write concurrency. This type of parallelism can be achieved both at the language level and at the system level. -% -% \begin{center} -% \begin{tabular}[t]{|c|c|c|} -% Sequential & System Parallel & Language Parallel \\ -% \begin{lstlisting} -% void big_sum(int* a, int* b, -% int* out, -% size_t length) -% { -% for(int i = 0; i < length; ++i ) { -% out[i] = a[i] + b[i]; -% } -% } -% -% -% -% -% -% int* a[10000]; -% int* b[10000]; -% int* c[10000]; -% //... fill in a and b ... -% big_sum(a, b, c, 10000); -% \end{lstlisting} &\begin{lstlisting} -% void big_sum(int* a, int* b, -% int* out, -% size_t length) -% { -% range ar(a, a + length); -% range br(b, b + length); -% range or(out, out + length); -% parfor( ai, bi, oi, -% [](int* ai, int* bi, int* oi) { -% oi = ai + bi; -% }); -% } -% -% int* a[10000]; -% int* b[10000]; -% int* c[10000]; -% //... fill in a and b ... -% big_sum(a, b, c, 10000); -% \end{lstlisting}&\begin{lstlisting} -% void big_sum(int* a, int* b, -% int* out, -% size_t length) -% { -% for (ai, bi, oi) in (a, b, out) { -% oi = ai + bi; -% } -% } -% -% -% -% -% -% int* a[10000]; -% int* b[10000]; -% int* c[10000]; -% //... fill in a and b ... -% big_sum(a, b, c, 10000); -% \end{lstlisting} -% \end{tabular} -% \end{center} -% -% \subsection{Machine setup}\label{machine} -% Threads are all good and well but wee still some OS support to fully utilize available hardware. -% -% \textbf{\large{Work in progress...}} Do wee need something beyond specifying the number of kernel threads? +Given these building blocks, it is possible to reproduce all three of the popular paradigms. Indeed, \glspl{uthread} is the default paradigm in \CFA. However, disabling \glspl{preemption} on the \gls{cfacluster} means \glspl{cfathread} effectively become \glspl{fiber}. Since several \glspl{cfacluster} with different scheduling policy can coexist in the same application, this allows \glspl{fiber} and \glspl{uthread} to coexist in the runtime of an application. Finally, it is possible to build executors for thread pools from \glspl{uthread} or \glspl{fiber}. Index: doc/proposals/concurrency/text/together.tex =================================================================== --- doc/proposals/concurrency/text/together.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) +++ doc/proposals/concurrency/text/together.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -0,0 +1,76 @@ +% ====================================================================== +% ====================================================================== +\chapter{Putting it all together} +% ====================================================================== +% ====================================================================== + + +\section{Threads as monitors} +As it was sbtely alluded in section \ref{threads}, \code{threads} in \CFA are in factor monitors. This means that all the monitors features are available when using threads. For example, here is a very simple two thread pipeline that could be used for a simulator of a game engine : +\begin{cfacode} +// Visualization declaration +thread Renderer {} renderer; +Frame * simulate( Simulator & this ); + +// Simulation declaration +thread Simulator{} simulator; +void render( Renderer & this ); + +// Blocking call used as communication +void draw( Renderer & mutex this, Frame * frame ); + +// Simualation loop +void main( Simulator & this ) { + while( true ) { + Frame * frame = simulate( this ); + draw( renderer, frame ); + } +} + +// Rendering loop +void main( Renderer & this ) { + while( true ) { + waitfor( draw, this ); + render( this ); + } +} +\end{cfacode} +One of the obvious complaints of the previous code snippet (other than its toy-like simplicity) is that it does not handle exit conditions and just goes on for ever. Luckily, the monitor semantics can also be used to clearly enforce a shutdown order in a concise manner : +\begin{cfacode} +// Visualization declaration +thread Renderer {} renderer; +Frame * simulate( Simulator & this ); + +// Simulation declaration +thread Simulator{} simulator; +void render( Renderer & this ); + +// Blocking call used as communication +void draw( Renderer & mutex this, Frame * frame ); + +// Simualation loop +void main( Simulator & this ) { + while( true ) { + Frame * frame = simulate( this ); + draw( renderer, frame ); + + // Exit main loop after the last frame + if( frame->is_last ) break; + } +} + +// Rendering loop +void main( Renderer & this ) { + while( true ) { + waitfor( draw, this ); + or waitfor( ^?{}, this ) { + // Add an exit condition + break; + } + + render( this ); + } +} +\end{cfacode} + +\section{Fibers \& Threads} Index: doc/proposals/concurrency/thesis.tex =================================================================== --- doc/proposals/concurrency/thesis.tex (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/thesis.tex (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -1,10 +1,10 @@ % requires tex packages: texlive-base texlive-latex-base tex-common texlive-humanities texlive-latex-extra texlive-fonts-recommended -% inline code ©...© (copyright symbol) emacs: C-q M-) -% red highlighting ®...® (registered trademark symbol) emacs: C-q M-. -% blue highlighting ß...ß (sharp s symbol) emacs: C-q M-_ -% green highlighting ¢...¢ (cent symbol) emacs: C-q M-" -% LaTex escape §...§ (section symbol) emacs: C-q M-' -% keyword escape ¶...¶ (pilcrow symbol) emacs: C-q M-^ +% inline code �...� (copyright symbol) emacs: C-q M-) +% red highlighting �...� (registered trademark symbol) emacs: C-q M-. +% blue highlighting �...� (sharp s symbol) emacs: C-q M-_ +% green highlighting �...� (cent symbol) emacs: C-q M-" +% LaTex escape �...� (section symbol) emacs: C-q M-' +% keyword escape �...� (pilcrow symbol) emacs: C-q M-^ % math escape $...$ (dollar symbol) @@ -27,5 +27,5 @@ \usepackage{multicol} \usepackage[acronym]{glossaries} -\usepackage{varioref} +\usepackage{varioref} \usepackage{listings} % format program code \usepackage[flushmargin]{footmisc} % support label/reference in footnote @@ -103,11 +103,9 @@ \input{parallelism} -\chapter{Putting it all together} +\input{together} + +\input{future} \chapter{Conclusion} - -\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} \section*{Acknowledgements} Index: doc/proposals/concurrency/version =================================================================== --- doc/proposals/concurrency/version (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ doc/proposals/concurrency/version (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -1,1 +1,1 @@ -0.9.180 +0.10.2 Index: src/CodeGen/CodeGenerator.cc =================================================================== --- src/CodeGen/CodeGenerator.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/CodeGen/CodeGenerator.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -443,11 +443,11 @@ void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) { extension( untypedExpr ); - if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) { + if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) { OperatorInfo opInfo; - if ( operatorLookup( nameExpr->get_name(), opInfo ) ) { - std::list< Expression* >::iterator arg = untypedExpr->get_args().begin(); + if ( operatorLookup( nameExpr->name, opInfo ) ) { + std::list< Expression* >::iterator arg = untypedExpr->args.begin(); switch ( opInfo.type ) { case OT_INDEX: - assert( untypedExpr->get_args().size() == 2 ); + assert( untypedExpr->args.size() == 2 ); (*arg++)->accept( *visitor ); output << "["; @@ -461,5 +461,5 @@ case OT_CTOR: case OT_DTOR: - if ( untypedExpr->get_args().size() == 1 ) { + if ( untypedExpr->args.size() == 1 ) { // the expression fed into a single parameter constructor or destructor may contain side // effects, so must still output this expression @@ -480,5 +480,5 @@ (*arg++)->accept( *visitor ); output << opInfo.symbol << "{ "; - genCommaList( arg, untypedExpr->get_args().end() ); + genCommaList( arg, untypedExpr->args.end() ); output << "}) /* " << opInfo.inputName << " */"; } // if @@ -488,5 +488,5 @@ case OT_PREFIXASSIGN: case OT_LABELADDRESS: - assert( untypedExpr->get_args().size() == 1 ); + assert( untypedExpr->args.size() == 1 ); output << "("; output << opInfo.symbol; @@ -497,5 +497,5 @@ case OT_POSTFIX: case OT_POSTFIXASSIGN: - assert( untypedExpr->get_args().size() == 1 ); + assert( untypedExpr->args.size() == 1 ); (*arg)->accept( *visitor ); output << opInfo.symbol; @@ -504,5 +504,5 @@ case OT_INFIX: case OT_INFIXASSIGN: - assert( untypedExpr->get_args().size() == 2 ); + assert( untypedExpr->args.size() == 2 ); output << "("; (*arg++)->accept( *visitor ); @@ -517,20 +517,14 @@ } // switch } else { - if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2 - assert( untypedExpr->get_args().size() == 2 ); - (*untypedExpr->get_args().begin())->accept( *visitor ); - output << " ... "; - (*--untypedExpr->get_args().end())->accept( *visitor ); - } else { // builtin routines - nameExpr->accept( *visitor ); - output << "("; - genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() ); - output << ")"; - } // if + // builtin routines + nameExpr->accept( *visitor ); + output << "("; + genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() ); + output << ")"; } // if } else { - untypedExpr->get_function()->accept( *visitor ); + untypedExpr->function->accept( *visitor ); output << "("; - genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() ); + genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() ); output << ")"; } // if @@ -538,7 +532,7 @@ void CodeGenerator::postvisit( RangeExpr * rangeExpr ) { - rangeExpr->get_low()->accept( *visitor ); + rangeExpr->low->accept( *visitor ); output << " ... "; - rangeExpr->get_high()->accept( *visitor ); + rangeExpr->high->accept( *visitor ); } @@ -885,4 +879,6 @@ void CodeGenerator::postvisit( CaseStmt * caseStmt ) { + updateLocation( caseStmt ); + output << indent; if ( caseStmt->isDefault()) { output << "default"; @@ -1026,4 +1022,13 @@ } // namespace CodeGen +std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ) { + if ( node ) { + node->print( out ); + } else { + out << "nullptr"; + } + return out; +} + // Local Variables: // // tab-width: 4 // Index: src/Concurrency/Keywords.cc =================================================================== --- src/Concurrency/Keywords.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/Concurrency/Keywords.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -528,5 +528,4 @@ DeclarationWithType * param = decl->get_functionType()->get_parameters().front(); auto type = dynamic_cast< StructInstType * >( InitTweak::getPointerBase( param->get_type() ) ); - // if( type ) std::cerr << "FRED2" << std::endl; if( type && type->get_baseStruct()->is_thread() ) { addStartStatement( decl, param ); Index: src/Concurrency/Waitfor.cc =================================================================== --- src/Concurrency/Waitfor.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/Concurrency/Waitfor.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -27,5 +27,5 @@ #include "InitTweak/InitTweak.h" // for getPointerBase #include "Parser/LinkageSpec.h" // for Cforall -#include "SymTab/AddVisit.h" // for acceptAndAdd +#include "ResolvExpr/Resolver.h" // for findVoidExpression #include "SynTree/Constant.h" // for Constant #include "SynTree/Declaration.h" // for StructDecl, FunctionDecl, ObjectDecl @@ -112,5 +112,5 @@ //============================================================================================= - class GenerateWaitForPass final : public WithStmtsToAdd { + class GenerateWaitForPass final : public WithIndexer { public: @@ -126,9 +126,11 @@ ObjectDecl * declare( unsigned long count, CompoundStmt * stmt ); + ObjectDecl * declareFlag( CompoundStmt * stmt ); + Statement * makeSetter( ObjectDecl * flag ); ObjectDecl * declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ); - void init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ); - Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, CompoundStmt * stmt ); - Expression * call(); - void choose(); + void init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * settter, CompoundStmt * stmt ); + Expression * init_timeout( Expression *& time, Expression *& time_cond, bool has_else, Expression *& else_cond, Statement * settter, CompoundStmt * stmt ); + Expression * call(size_t count, ObjectDecl * acceptables, Expression * timeout, CompoundStmt * stmt); + void choose( WaitForStmt * waitfor, Expression * result, CompoundStmt * stmt ); static void implement( std::list< Declaration * > & translationUnit ) { @@ -140,15 +142,15 @@ private: FunctionDecl * decl_waitfor = nullptr; + StructDecl * decl_mask = nullptr; StructDecl * decl_acceptable = nullptr; StructDecl * decl_monitor = nullptr; - DeclarationWithType * decl_m_func = nullptr; - DeclarationWithType * decl_m_count = nullptr; - DeclarationWithType * decl_m_monitors = nullptr; - DeclarationWithType * decl_m_isdtor = nullptr; static std::unique_ptr< Type > generic_func; + UniqueName namer_acc = "__acceptables_"s; + UniqueName namer_idx = "__index_"s; + UniqueName namer_flg = "__do_run_"s; + UniqueName namer_msk = "__mask_"s; UniqueName namer_mon = "__monitors_"s; - UniqueName namer_acc = "__acceptables_"s; UniqueName namer_tim = "__timeout_"s; }; @@ -167,5 +169,5 @@ namespace { Expression * makeOpIndex( DeclarationWithType * array, unsigned long index ) { - return new ApplicationExpr( + return new UntypedExpr( new NameExpr( "?[?]" ), { @@ -177,5 +179,5 @@ Expression * makeOpAssign( Expression * lhs, Expression * rhs ) { - return new ApplicationExpr( + return new UntypedExpr( new NameExpr( "?=?" ), { lhs, rhs } @@ -183,22 +185,21 @@ } - Expression * makeOpMember( Expression * sue, DeclarationWithType * mem ) { - return new MemberExpr( mem, sue ); - } - - Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, DeclarationWithType * member, Expression * value ) { - return new ExprStmt( - noLabels, - makeOpAssign( - makeOpMember( - makeOpIndex( - object, - index - ), - member + Expression * makeOpMember( Expression * sue, const std::string & mem ) { + return new UntypedMemberExpr( new NameExpr( mem ), sue ); + } + + Statement * makeAccStatement( DeclarationWithType * object, unsigned long index, const std::string & member, Expression * value, const SymTab::Indexer & indexer ) { + std::unique_ptr< Expression > expr( makeOpAssign( + makeOpMember( + makeOpIndex( + object, + index ), - value - ) - ); + member + ), + value + ) ); + + return new ExprStmt( noLabels, ResolvExpr::findVoidExpression( expr.get(), indexer ) ); } @@ -208,4 +209,19 @@ return new ConstantExpr( Constant::from_bool( ifnull ) ); } + + VariableExpr * extractVariable( Expression * func ) { + if( VariableExpr * var = dynamic_cast< VariableExpr * >( func ) ) { + return var; + } + + CastExpr * cast = strict_dynamic_cast< CastExpr * >( func ); + return strict_dynamic_cast< VariableExpr * >( cast->arg ); + } + + Expression * detectIsDtor( Expression * func ) { + VariableExpr * typed_func = extractVariable( func ); + bool is_dtor = InitTweak::isDestructor( typed_func->var ); + return new ConstantExpr( Constant::from_bool( is_dtor ) ); + } }; @@ -216,5 +232,5 @@ void GenerateWaitForPass::premutate( FunctionDecl * decl) { - if( decl->name != "__accept_internal" ) return; + if( decl->name != "__waitfor_internal" ) return; decl_waitfor = decl; @@ -227,11 +243,8 @@ assert( !decl_acceptable ); decl_acceptable = decl; - for( Declaration * field : decl_acceptable->members ) { - if( field->name == "func" ) decl_m_func = strict_dynamic_cast< DeclarationWithType * >( field ); - else if( field->name == "count" ) decl_m_count = strict_dynamic_cast< DeclarationWithType * >( field ); - else if( field->name == "monitor" ) decl_m_monitors = strict_dynamic_cast< DeclarationWithType * >( field ); - else if( field->name == "is_dtor" ) decl_m_isdtor = strict_dynamic_cast< DeclarationWithType * >( field ); - } - + } + else if( decl->name == "__waitfor_mask_t" ) { + assert( !decl_mask ); + decl_mask = decl; } else if( decl->name == "monitor_desc" ) { @@ -242,15 +255,15 @@ Statement * GenerateWaitForPass::postmutate( WaitForStmt * waitfor ) { - return waitfor; - - if( !decl_monitor || !decl_acceptable ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include ", waitfor ); + if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include ", waitfor ); CompoundStmt * stmt = new CompoundStmt( noLabels ); ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt ); + ObjectDecl * flag = declareFlag( stmt ); + Statement * setter = makeSetter( flag ); int index = 0; for( auto & clause : waitfor->clauses ) { - init( acceptables, index, clause, stmt ); + init( acceptables, index, clause, setter, stmt ); index++; @@ -262,10 +275,19 @@ waitfor->orelse .statement, waitfor->orelse .condition, + setter, stmt ); - // Expression * result = call( acceptables, timeout, orelse, stmt ); - - // choose( waitfor, result ); + CompoundStmt * compound = new CompoundStmt( noLabels ); + stmt->push_back( new IfStmt( + noLabels, + safeCond( new VariableExpr( flag ) ), + compound, + nullptr + )); + + Expression * result = call( waitfor->clauses.size(), acceptables, timeout, compound ); + + choose( waitfor, result, compound ); return stmt; @@ -274,9 +296,6 @@ ObjectDecl * GenerateWaitForPass::declare( unsigned long count, CompoundStmt * stmt ) { - ObjectDecl * acceptables = new ObjectDecl( + ObjectDecl * acceptables = ObjectDecl::newObject( namer_acc.newName(), - noStorage, - LinkageSpec::Cforall, - nullptr, new ArrayType( noQualifiers, @@ -294,19 +313,63 @@ stmt->push_back( new DeclStmt( noLabels, acceptables) ); + UntypedExpr * set = new UntypedExpr( + new NameExpr( "__builtin_memset" ), + { + new VariableExpr( acceptables ), + new ConstantExpr( Constant::from_int( 0 ) ), + new SizeofExpr( new VariableExpr( acceptables ) ) + } + ); + + Expression * resolved_set = ResolvExpr::findVoidExpression( set, indexer ); + delete set; + + stmt->push_back( new ExprStmt( noLabels, resolved_set ) ); + return acceptables; } + ObjectDecl * GenerateWaitForPass::declareFlag( CompoundStmt * stmt ) { + ObjectDecl * flag = ObjectDecl::newObject( + namer_flg.newName(), + new BasicType( + noQualifiers, + BasicType::Bool + ), + new SingleInit( new ConstantExpr( Constant::from_ulong( 0 ) ) ) + ); + + stmt->push_back( new DeclStmt( noLabels, flag) ); + + return flag; + } + + Statement * GenerateWaitForPass::makeSetter( ObjectDecl * flag ) { + Expression * untyped = new UntypedExpr( + new NameExpr( "?=?" ), + { + new VariableExpr( flag ), + new ConstantExpr( Constant::from_ulong( 1 ) ) + } + ); + + Expression * expr = ResolvExpr::findVoidExpression( untyped, indexer ); + delete untyped; + + return new ExprStmt( noLabels, expr ); + } + ObjectDecl * GenerateWaitForPass::declMon( WaitForStmt::Clause & clause, CompoundStmt * stmt ) { - ObjectDecl * mon = new ObjectDecl( + ObjectDecl * mon = ObjectDecl::newObject( namer_mon.newName(), - noStorage, - LinkageSpec::Cforall, - nullptr, new ArrayType( noQualifiers, - new StructInstType( + new PointerType( noQualifiers, - decl_monitor + new StructInstType( + noQualifiers, + decl_monitor + ) ), new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), @@ -316,5 +379,21 @@ new ListInit( map_range < std::list > ( clause.target.arguments, [this](Expression * expr ){ - return new SingleInit( expr ); + Expression * untyped = new CastExpr( + new UntypedExpr( + new NameExpr( "get_monitor" ), + { expr } + ), + new PointerType( + noQualifiers, + new StructInstType( + noQualifiers, + decl_monitor + ) + ) + ); + + Expression * init = ResolvExpr::findSingleExpression( untyped, indexer ); + delete untyped; + return new SingleInit( init ); }) ) @@ -326,18 +405,20 @@ } - void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, CompoundStmt * stmt ) { + void GenerateWaitForPass::init( ObjectDecl * acceptables, int index, WaitForStmt::Clause & clause, Statement * setter, CompoundStmt * stmt ) { ObjectDecl * monitors = declMon( clause, stmt ); - CompoundStmt * compound = new CompoundStmt( noLabels ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_func , clause.target.function ) ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_count , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ) ) ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_monitors, new VariableExpr( monitors ) ) ); - compound->push_back( makeAccStatement( acceptables, index, decl_m_isdtor , new ConstantExpr( Constant::from_bool( true ) ) ) ); + Type * fptr_t = new PointerType( noQualifiers, new FunctionType( noQualifiers, true ) ); stmt->push_back( new IfStmt( noLabels, safeCond( clause.condition ), - compound, + new CompoundStmt({ + makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function ) , indexer ), + makeAccStatement( acceptables, index, "func" , new CastExpr( clause.target.function, fptr_t ) , indexer ), + makeAccStatement( acceptables, index, "list" , new VariableExpr( monitors ) , indexer ), + makeAccStatement( acceptables, index, "size" , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ), + setter->clone() + }), nullptr )); @@ -353,11 +434,9 @@ bool has_else, Expression *& else_cond, + Statement * setter, CompoundStmt * stmt ) { - ObjectDecl * timeout = new ObjectDecl( + ObjectDecl * timeout = ObjectDecl::newObject( namer_tim.newName(), - noStorage, - LinkageSpec::Cforall, - nullptr, new BasicType( noQualifiers, @@ -374,12 +453,15 @@ stmt->push_back( new IfStmt( noLabels, - safeCond( else_cond ), - new ExprStmt( - noLabels, - makeOpAssign( - new VariableExpr( timeout ), - time - ) - ), + safeCond( time_cond ), + new CompoundStmt({ + new ExprStmt( + noLabels, + makeOpAssign( + new VariableExpr( timeout ), + time + ) + ), + setter->clone() + }), nullptr )); @@ -392,11 +474,14 @@ noLabels, safeCond( else_cond ), - new ExprStmt( - noLabels, - makeOpAssign( - new VariableExpr( timeout ), - new ConstantExpr( Constant::from_ulong( 0 ) ) - ) - ), + new CompoundStmt({ + new ExprStmt( + noLabels, + makeOpAssign( + new VariableExpr( timeout ), + new ConstantExpr( Constant::from_ulong( 0 ) ) + ) + ), + setter->clone() + }), nullptr )); @@ -405,5 +490,130 @@ } + delete setter; + return new VariableExpr( timeout ); + } + + Expression * GenerateWaitForPass::call( + size_t count, + ObjectDecl * acceptables, + Expression * timeout, + CompoundStmt * stmt + ) { + ObjectDecl * index = ObjectDecl::newObject( + namer_idx.newName(), + new BasicType( + noQualifiers, + BasicType::ShortSignedInt + ), + new SingleInit( + new ConstantExpr( Constant::from_int( -1 ) ) + ) + ); + + stmt->push_back( new DeclStmt( noLabels, index ) ); + + ObjectDecl * mask = ObjectDecl::newObject( + namer_msk.newName(), + new StructInstType( + noQualifiers, + decl_mask + ), + new ListInit({ + new SingleInit( new AddressExpr( new VariableExpr( index ) ) ), + new SingleInit( new VariableExpr( acceptables ) ), + new SingleInit( new ConstantExpr( Constant::from_ulong( count ) ) ) + }) + ); + + stmt->push_back( new DeclStmt( noLabels, mask ) ); + + stmt->push_back( new ExprStmt( + noLabels, + new ApplicationExpr( + VariableExpr::functionPointer( decl_waitfor ), + { + new CastExpr( + new VariableExpr( mask ), + new ReferenceType( + noQualifiers, + new StructInstType( + noQualifiers, + decl_mask + ) + ) + ), + timeout + } + ) + )); + + return new VariableExpr( index ); + } + + void GenerateWaitForPass::choose( + WaitForStmt * waitfor, + Expression * result, + CompoundStmt * stmt + ) { + SwitchStmt * swtch = new SwitchStmt( + noLabels, + result, + std::list() + ); + + unsigned long i = 0; + for( auto & clause : waitfor->clauses ) { + swtch->statements.push_back( + new CaseStmt( + noLabels, + new ConstantExpr( Constant::from_ulong( i++ ) ), + { + clause.statement, + new BranchStmt( + noLabels, + "", + BranchStmt::Break + ) + } + ) + ); + } + + if(waitfor->timeout.statement) { + swtch->statements.push_back( + new CaseStmt( + noLabels, + new ConstantExpr( Constant::from_int( -2 ) ), + { + waitfor->timeout.statement, + new BranchStmt( + noLabels, + "", + BranchStmt::Break + ) + } + ) + ); + } + + if(waitfor->orelse.statement) { + swtch->statements.push_back( + new CaseStmt( + noLabels, + new ConstantExpr( Constant::from_int( -1 ) ), + { + waitfor->orelse.statement, + new BranchStmt( + noLabels, + "", + BranchStmt::Break + ) + } + ) + ); + } + + stmt->push_back( swtch ); } }; Index: src/GenPoly/Box.cc =================================================================== --- src/GenPoly/Box.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/GenPoly/Box.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -32,5 +32,4 @@ #include "Common/UniqueName.h" // for UniqueName #include "Common/utility.h" // for toString -#include "DeclMutator.h" // for DeclMutator #include "FindFunction.h" // for findFunction, findAndReplace... #include "GenPoly/ErasableScopedMap.h" // for ErasableScopedMap<>::const_i... @@ -39,5 +38,4 @@ #include "Lvalue.h" // for generalizedLvalue #include "Parser/LinkageSpec.h" // for C, Spec, Cforall, Intrinsic -#include "PolyMutator.h" // for PolyMutator #include "ResolvExpr/TypeEnvironment.h" // for EqvClass #include "ResolvExpr/typeops.h" // for typesCompatible @@ -62,35 +60,37 @@ FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars ); + class BoxPass { + protected: + BoxPass() : scopeTyVars( TypeDecl::Data{} ) {} + TyVarMap scopeTyVars; + }; + /// Adds layout-generation functions to polymorphic types - class LayoutFunctionBuilder final : public DeclMutator { - unsigned int functionNesting; // current level of nested functions + class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef, public WithShortCircuiting { + unsigned int functionNesting = 0; // current level of nested functions public: - LayoutFunctionBuilder() : functionNesting( 0 ) {} - - using DeclMutator::mutate; - virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override; - virtual Declaration *mutate( StructDecl *structDecl ) override; - virtual Declaration *mutate( UnionDecl *unionDecl ) override; + void previsit( FunctionDecl *functionDecl ); + void previsit( StructDecl *structDecl ); + void previsit( UnionDecl *unionDecl ); }; /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call - class Pass1 final : public PolyMutator { + class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef, public WithShortCircuiting { public: Pass1(); - using PolyMutator::mutate; - virtual Expression *mutate( ApplicationExpr *appExpr ) override; - virtual Expression *mutate( AddressExpr *addrExpr ) override; - virtual Expression *mutate( UntypedExpr *expr ) override; - virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override; - virtual TypeDecl *mutate( TypeDecl *typeDecl ) override; - virtual Expression *mutate( CommaExpr *commaExpr ) override; - virtual Expression *mutate( ConditionalExpr *condExpr ) override; - virtual Statement * mutate( ReturnStmt *returnStmt ) override; - virtual Type *mutate( PointerType *pointerType ) override; - virtual Type * mutate( FunctionType *functionType ) override; - - virtual void doBeginScope() override; - virtual void doEndScope() override; + void premutate( FunctionDecl * functionDecl ); + void premutate( TypeDecl * typeDecl ); + void premutate( CommaExpr * commaExpr ); + Expression * postmutate( ApplicationExpr * appExpr ); + Expression * postmutate( UntypedExpr *expr ); + void premutate( AddressExpr * addrExpr ); + Expression * postmutate( AddressExpr * addrExpr ); + void premutate( ReturnStmt * returnStmt ); + void premutate( PointerType * pointerType ); + void premutate( FunctionType * functionType ); + + void beginScope(); + void endScope(); private: /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application @@ -129,22 +129,14 @@ /// * Moves polymorphic returns in function types to pointer-type parameters /// * adds type size and assertion parameters to parameter lists - class Pass2 final : public PolyMutator { - public: - template< typename DeclClass > - DeclClass *handleDecl( DeclClass *decl ); - template< typename AggDecl > - AggDecl * handleAggDecl( AggDecl * aggDecl ); - - typedef PolyMutator Parent; - using Parent::mutate; - virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override; - virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override; - virtual StructDecl *mutate( StructDecl *structDecl ) override; - virtual UnionDecl *mutate( UnionDecl *unionDecl ) override; - virtual TraitDecl *mutate( TraitDecl *unionDecl ) override; - virtual TypeDecl *mutate( TypeDecl *typeDecl ) override; - virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override; - virtual Type *mutate( PointerType *pointerType ) override; - virtual Type *mutate( FunctionType *funcType ) override; + struct Pass2 final : public BoxPass, public WithGuards { + void handleAggDecl(); + + DeclarationWithType * postmutate( FunctionDecl *functionDecl ); + void premutate( StructDecl *structDecl ); + void premutate( UnionDecl *unionDecl ); + void premutate( TraitDecl *unionDecl ); + void premutate( TypeDecl *typeDecl ); + void premutate( PointerType *pointerType ); + void premutate( FunctionType *funcType ); private: @@ -158,5 +150,5 @@ /// * Calculates polymorphic offsetof expressions from offset array /// * Inserts dynamic calculation of polymorphic type layouts where needed - class PolyGenericCalculator final : public WithGuards, public WithVisitorRef, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution { + class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution { public: PolyGenericCalculator(); @@ -197,23 +189,19 @@ ScopedSet< std::string > knownOffsets; ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName UniqueName bufNamer; ///< Namer for VLA buffers - TyVarMap scopeTyVars; }; /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations. - class Pass3 final : public PolyMutator { - public: + struct Pass3 final : public BoxPass, public WithGuards { template< typename DeclClass > - DeclClass *handleDecl( DeclClass *decl, Type *type ); - - using PolyMutator::mutate; - virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override; - virtual Declaration *mutate( StructDecl *structDecl ) override; - virtual Declaration *mutate( UnionDecl *unionDecl ) override; - virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override; - virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override; - virtual TypeDecl *mutate( TypeDecl *objectDecl ) override; - virtual Type *mutate( PointerType *pointerType ) override; - virtual Type *mutate( FunctionType *funcType ) override; - private: + void handleDecl( DeclClass * decl, Type * type ); + + void premutate( ObjectDecl * objectDecl ); + void premutate( FunctionDecl * functionDecl ); + void premutate( TypedefDecl * typedefDecl ); + void premutate( StructDecl * structDecl ); + void premutate( UnionDecl * unionDecl ); + void premutate( TypeDecl * typeDecl ); + void premutate( PointerType * pointerType ); + void premutate( FunctionType * funcType ); }; } // anonymous namespace @@ -247,25 +235,25 @@ void box( std::list< Declaration *>& translationUnit ) { - LayoutFunctionBuilder layoutBuilder; - Pass1 pass1; - Pass2 pass2; + PassVisitor layoutBuilder; + PassVisitor pass1; + PassVisitor pass2; PassVisitor polyCalculator; - Pass3 pass3; - - layoutBuilder.mutateDeclarationList( translationUnit ); - mutateTranslationUnit/*All*/( translationUnit, pass1 ); - mutateTranslationUnit/*All*/( translationUnit, pass2 ); + PassVisitor pass3; + + acceptAll( translationUnit, layoutBuilder ); + mutateAll( translationUnit, pass1 ); + mutateAll( translationUnit, pass2 ); mutateAll( translationUnit, polyCalculator ); - mutateTranslationUnit/*All*/( translationUnit, pass3 ); + mutateAll( translationUnit, pass3 ); } ////////////////////////////////// LayoutFunctionBuilder //////////////////////////////////////////// - DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) { - functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) ); + void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) { + visit_children = false; + maybeAccept( functionDecl->get_functionType(), *visitor ); ++functionNesting; - functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + maybeAccept( functionDecl->get_statements(), *visitor ); --functionNesting; - return functionDecl; } @@ -356,11 +344,12 @@ } - Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) { + void LayoutFunctionBuilder::previsit( StructDecl *structDecl ) { // do not generate layout function for "empty" tag structs - if ( structDecl->get_members().empty() ) return structDecl; + visit_children = false; + if ( structDecl->get_members().empty() ) return; // get parameters that can change layout, exiting early if none std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() ); - if ( otypeParams.empty() ) return structDecl; + if ( otypeParams.empty() ) return; // build layout function signature @@ -413,15 +402,15 @@ addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) ); - addDeclarationAfter( layoutDecl ); - return structDecl; + declsToAddAfter.push_back( layoutDecl ); } - Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) { + void LayoutFunctionBuilder::previsit( UnionDecl *unionDecl ) { // do not generate layout function for "empty" tag unions - if ( unionDecl->get_members().empty() ) return unionDecl; + visit_children = false; + if ( unionDecl->get_members().empty() ) return; // get parameters that can change layout, exiting early if none std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() ); - if ( otypeParams.empty() ) return unionDecl; + if ( otypeParams.empty() ) return; // build layout function signature @@ -456,6 +445,5 @@ addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) ); - addDeclarationAfter( layoutDecl ); - return unionDecl; + declsToAddAfter.push_back( layoutDecl ); } @@ -501,31 +489,29 @@ Pass1::Pass1() : tempNamer( "_temp" ) {} - DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) { + void Pass1::premutate( FunctionDecl *functionDecl ) { if ( functionDecl->get_statements() ) { // empty routine body ? // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl; - doBeginScope(); - scopeTyVars.beginScope(); - - DeclarationWithType *oldRetval = retval; + GuardScope( scopeTyVars ); + GuardValue( retval ); // process polymorphic return value retval = nullptr; - if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) { - retval = functionDecl->get_functionType()->get_returnVals().front(); + FunctionType *functionType = functionDecl->type; + if ( isDynRet( functionType ) && functionDecl->linkage != LinkageSpec::C ) { + retval = functionType->returnVals.front(); // give names to unnamed return values - if ( retval->get_name() == "" ) { - retval->set_name( "_retparm" ); - retval->set_linkage( LinkageSpec::C ); + if ( retval->name == "" ) { + retval->name = "_retparm"; + retval->linkage = LinkageSpec::C; } // if } // if - FunctionType *functionType = functionDecl->get_functionType(); - makeTyVarMap( functionDecl->get_functionType(), scopeTyVars ); - - std::list< DeclarationWithType *> ¶mList = functionType->get_parameters(); + makeTyVarMap( functionType, scopeTyVars ); + + std::list< DeclarationWithType *> ¶mList = functionType->parameters; std::list< FunctionType *> functions; - for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) { - for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) { + for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) { + for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) { findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter ); } // for @@ -542,21 +528,13 @@ } // if } // for - - functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) ); - - scopeTyVars.endScope(); - retval = oldRetval; - doEndScope(); // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl; } // if - return functionDecl; - } - - TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) { + } + + void Pass1::premutate( TypeDecl *typeDecl ) { addToTyVarMap( typeDecl, scopeTyVars ); - return dynamic_cast( Mutator::mutate( typeDecl ) ); - } - - Expression *Pass1::mutate( CommaExpr *commaExpr ) { + } + + void Pass1::premutate( CommaExpr *commaExpr ) { // Attempting to find application expressions that were mutated by the copy constructor passes // to use an explicit return variable, so that the variable can be reused as a parameter to the @@ -574,16 +552,4 @@ } } - - commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) ); - commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) ); - return commaExpr; - } - - Expression *Pass1::mutate( ConditionalExpr *condExpr ) { - condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) ); - condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) ); - condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) ); - return condExpr; - } @@ -659,5 +625,5 @@ ObjectDecl *Pass1::makeTemporary( Type *type ) { ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 ); - stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) ); return newObj; } @@ -775,9 +741,9 @@ ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 ); newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right??? - stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) ); UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax? assign->get_args().push_back( new VariableExpr( newObj ) ); assign->get_args().push_back( arg ); - stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) ); + stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) ); arg = new AddressExpr( new VariableExpr( newObj ) ); } // if @@ -961,5 +927,5 @@ std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) ); adapter = answer.first; - stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) ); } // if assert( adapter != adapters.end() ); @@ -1118,5 +1084,5 @@ } - Expression *Pass1::mutate( ApplicationExpr *appExpr ) { + Expression *Pass1::postmutate( ApplicationExpr *appExpr ) { // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl; // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) { @@ -1124,10 +1090,8 @@ // } // std::cerr << "\n"; - appExpr->get_function()->acceptMutator( *this ); - mutateAll( appExpr->get_args(), *this ); - - assert( appExpr->get_function()->has_result() ); - FunctionType * function = getFunctionType( appExpr->get_function()->get_result() ); - assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() ); + + assert( appExpr->function->result ); + FunctionType * function = getFunctionType( appExpr->function->result ); + assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() ); if ( Expression *newExpr = handleIntrinsics( appExpr ) ) { @@ -1182,19 +1146,20 @@ } - Expression *Pass1::mutate( UntypedExpr *expr ) { - if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) { - if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) { + Expression * Pass1::postmutate( UntypedExpr *expr ) { + if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) { + if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) { if ( name->get_name() == "*?" ) { - Expression *ret = expr->get_args().front(); - expr->get_args().clear(); + Expression *ret = expr->args.front(); + expr->args.clear(); delete expr; - return ret->acceptMutator( *this ); + return ret; } // if } // if } // if - return PolyMutator::mutate( expr ); - } - - Expression *Pass1::mutate( AddressExpr *addrExpr ) { + return expr; + } + + void Pass1::premutate( AddressExpr * ) { visit_children = false; } + Expression * Pass1::postmutate( AddressExpr * addrExpr ) { assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() ); @@ -1216,5 +1181,5 @@ // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward // out of the if condition. - addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) ); + addrExpr->arg = addrExpr->get_arg()->acceptMutator( *visitor ); // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env ); @@ -1231,40 +1196,27 @@ } - Statement * Pass1::mutate( ReturnStmt *returnStmt ) { - if ( retval && returnStmt->get_expr() ) { - assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() ); - delete returnStmt->get_expr(); - returnStmt->set_expr( 0 ); - } else { - returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) ); + void Pass1::premutate( ReturnStmt *returnStmt ) { + if ( retval && returnStmt->expr ) { + assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() ); + delete returnStmt->expr; + returnStmt->expr = nullptr; } // if - return returnStmt; - } - - Type * Pass1::mutate( PointerType *pointerType ) { - scopeTyVars.beginScope(); + } + + void Pass1::premutate( PointerType *pointerType ) { + GuardScope( scopeTyVars ); makeTyVarMap( pointerType, scopeTyVars ); - - Type *ret = Mutator::mutate( pointerType ); - - scopeTyVars.endScope(); - return ret; - } - - Type * Pass1::mutate( FunctionType *functionType ) { - scopeTyVars.beginScope(); + } + + void Pass1::premutate( FunctionType *functionType ) { + GuardScope( scopeTyVars ); makeTyVarMap( functionType, scopeTyVars ); - - Type *ret = Mutator::mutate( functionType ); - - scopeTyVars.endScope(); - return ret; - } - - void Pass1::doBeginScope() { + } + + void Pass1::beginScope() { adapters.beginScope(); } - void Pass1::doEndScope() { + void Pass1::endScope() { adapters.endScope(); } @@ -1293,13 +1245,5 @@ } - template< typename DeclClass > - DeclClass * Pass2::handleDecl( DeclClass *decl ) { - DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) ); - - return ret; - } - - DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) { - functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) ); + DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) { FunctionType * ftype = functionDecl->get_functionType(); if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) { @@ -1325,55 +1269,30 @@ } - ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) { - return handleDecl( objectDecl ); - } - - template< typename AggDecl > - AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) { + void Pass2::premutate( StructDecl * ) { // prevent tyVars from leaking into containing scope - scopeTyVars.beginScope(); - Parent::mutate( aggDecl ); - scopeTyVars.endScope(); - return aggDecl; - } - - StructDecl * Pass2::mutate( StructDecl *aggDecl ) { - return handleAggDecl( aggDecl ); - } - - UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) { - return handleAggDecl( aggDecl ); - } - - TraitDecl * Pass2::mutate( TraitDecl *aggDecl ) { - return handleAggDecl( aggDecl ); - } - - TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) { + GuardScope( scopeTyVars ); + } + + void Pass2::premutate( UnionDecl * ) { + // prevent tyVars from leaking into containing scope + GuardScope( scopeTyVars ); + } + + void Pass2::premutate( TraitDecl * ) { + // prevent tyVars from leaking into containing scope + GuardScope( scopeTyVars ); + } + + void Pass2::premutate( TypeDecl *typeDecl ) { addToTyVarMap( typeDecl, scopeTyVars ); - if ( typeDecl->get_base() ) { - return handleDecl( typeDecl ); - } else { - return dynamic_cast( Parent::mutate( typeDecl ) ); - } - } - - TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) { - return handleDecl( typedefDecl ); - } - - Type * Pass2::mutate( PointerType *pointerType ) { - scopeTyVars.beginScope(); + } + + void Pass2::premutate( PointerType *pointerType ) { + GuardScope( scopeTyVars ); makeTyVarMap( pointerType, scopeTyVars ); - - Type *ret = Parent::mutate( pointerType ); - - scopeTyVars.endScope(); - return ret; - } - - Type *Pass2::mutate( FunctionType *funcType ) { - scopeTyVars.beginScope(); - + } + + void Pass2::premutate( FunctionType *funcType ) { + GuardScope( scopeTyVars ); makeTyVarMap( funcType, scopeTyVars ); @@ -1414,5 +1333,4 @@ // move all assertions into parameter list for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) { -// *assert = (*assert)->acceptMutator( *this ); // assertion parameters may not be used in body, pass along with unused attribute. (*assert)->get_attributes().push_back( new Attribute( "unused" ) ); @@ -1450,5 +1368,4 @@ } } - seenTypes.insert( typeName ); } @@ -1458,9 +1375,4 @@ funcType->get_parameters().splice( last, inferredParams ); addAdapters( funcType ); - mutateAll( funcType->get_returnVals(), *this ); - mutateAll( funcType->get_parameters(), *this ); - - scopeTyVars.endScope(); - return funcType; } @@ -1468,5 +1380,5 @@ PolyGenericCalculator::PolyGenericCalculator() - : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {} + : knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {} void PolyGenericCalculator::beginTypeScope( Type *ty ) { @@ -1829,74 +1741,47 @@ template< typename DeclClass > - DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) { - scopeTyVars.beginScope(); + void Pass3::handleDecl( DeclClass * decl, Type * type ) { + GuardScope( scopeTyVars ); makeTyVarMap( type, scopeTyVars ); - - DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) ); - // ScrubTyVars::scrub( decl, scopeTyVars ); ScrubTyVars::scrubAll( decl ); - - scopeTyVars.endScope(); - return ret; - } - - ObjectDecl * Pass3::mutate( ObjectDecl *objectDecl ) { - return handleDecl( objectDecl, objectDecl->get_type() ); - } - - DeclarationWithType * Pass3::mutate( FunctionDecl *functionDecl ) { - return handleDecl( functionDecl, functionDecl->get_functionType() ); - } - - TypedefDecl * Pass3::mutate( TypedefDecl *typedefDecl ) { - return handleDecl( typedefDecl, typedefDecl->get_base() ); + } + + void Pass3::premutate( ObjectDecl * objectDecl ) { + handleDecl( objectDecl, objectDecl->type ); + } + + void Pass3::premutate( FunctionDecl * functionDecl ) { + handleDecl( functionDecl, functionDecl->type ); + } + + void Pass3::premutate( TypedefDecl * typedefDecl ) { + handleDecl( typedefDecl, typedefDecl->base ); } /// Strips the members from a generic aggregate - void stripGenericMembers(AggregateDecl* decl) { - if ( ! decl->get_parameters().empty() ) decl->get_members().clear(); - } - - Declaration *Pass3::mutate( StructDecl *structDecl ) { + void stripGenericMembers(AggregateDecl * decl) { + if ( ! decl->parameters.empty() ) decl->members.clear(); + } + + void Pass3::premutate( StructDecl * structDecl ) { stripGenericMembers( structDecl ); - return structDecl; - } - - Declaration *Pass3::mutate( UnionDecl *unionDecl ) { + } + + void Pass3::premutate( UnionDecl * unionDecl ) { stripGenericMembers( unionDecl ); - return unionDecl; - } - - TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) { -// Initializer *init = 0; -// std::list< Expression *> designators; -// addToTyVarMap( typeDecl, scopeTyVars ); -// if ( typeDecl->get_base() ) { -// init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators ); -// } -// return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init ); - + } + + void Pass3::premutate( TypeDecl * typeDecl ) { addToTyVarMap( typeDecl, scopeTyVars ); - return dynamic_cast( Mutator::mutate( typeDecl ) ); - } - - Type * Pass3::mutate( PointerType *pointerType ) { - scopeTyVars.beginScope(); + } + + void Pass3::premutate( PointerType * pointerType ) { + GuardScope( scopeTyVars ); makeTyVarMap( pointerType, scopeTyVars ); - - Type *ret = Mutator::mutate( pointerType ); - - scopeTyVars.endScope(); - return ret; - } - - Type * Pass3::mutate( FunctionType *functionType ) { - scopeTyVars.beginScope(); + } + + void Pass3::premutate( FunctionType * functionType ) { + GuardScope( scopeTyVars ); makeTyVarMap( functionType, scopeTyVars ); - - Type *ret = Mutator::mutate( functionType ); - - scopeTyVars.endScope(); - return ret; } } // anonymous namespace Index: c/GenPoly/DeclMutator.cc =================================================================== --- src/GenPoly/DeclMutator.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ (revision ) @@ -1,195 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// DeclMutator.cc -- -// -// Author : Aaron B. Moss -// Created On : Fri Nov 27 14:44:00 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thu Jun 22 13:49:00 2017 -// Update Count : 4 -// - -#include "DeclMutator.h" - -#include // for allocator_traits<>::value_type - -#include "Common/SemanticError.h" // for SemanticError -#include "SynTree/Declaration.h" // for Declaration -#include "SynTree/Expression.h" // for Expression -#include "SynTree/Label.h" // for Label, noLabels -#include "SynTree/Statement.h" // for CatchStmt, Statement, CompoundStmt - -namespace GenPoly { - DeclMutator::DeclMutator() : Mutator(), declsToAdd(1), declsToAddAfter(1) {} - - DeclMutator::~DeclMutator() {} - - void DeclMutator::mutateDeclarationList( std::list< Declaration* > &decls ) { - for ( std::list< Declaration* >::iterator decl = decls.begin(); ; ++decl ) { - // splice in new declarations after previous decl - decls.splice( decl, declsToAddAfter.back() ); - - if ( decl == decls.end() ) break; - - // run mutator on declaration - *decl = maybeMutate( *decl, *this ); - - // splice in new declarations before current decl - decls.splice( decl, declsToAdd.back() ); - } - } - - void DeclMutator::doBeginScope() { - // add new decl lists for inside of scope - declsToAdd.resize( declsToAdd.size()+1 ); - declsToAddAfter.resize( declsToAddAfter.size()+1 ); - } - - void DeclMutator::doEndScope() { - // splice any leftover declarations from this scope onto the containing scope - std::vector< std::list< Declaration* > >::reverse_iterator back = declsToAdd.rbegin(); - std::vector< std::list< Declaration* > >::reverse_iterator newBack = back + 1; - newBack->splice( newBack->end(), *back ); - declsToAdd.pop_back(); - - back = declsToAddAfter.rbegin(); - newBack = back + 1; - newBack->splice( newBack->end(), *back ); - declsToAddAfter.pop_back(); - } - - Statement* DeclMutator::mutateStatement( Statement *stmt ) { - // shunt over to compound statement handling if applicable - CompoundStmt *compoundStmt = dynamic_cast< CompoundStmt* >(stmt); - if ( compoundStmt ) return mutate( compoundStmt ); - - doBeginScope(); - - // run mutator on statement - stmt = maybeMutate( stmt, *this ); - // return if no declarations to add - if ( declsToAdd.back().empty() && declsToAddAfter.back().empty() ) { - doEndScope(); - return stmt; - } - - // otherwise add declarations to new compound statement - CompoundStmt *compound = new CompoundStmt( noLabels ); - for ( std::list< Declaration* >::iterator decl = declsToAdd.back().begin(); decl != declsToAdd.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - compound->get_kids().push_back( declStmt ); - } - declsToAdd.back().clear(); - - // add mutated statement - compound->get_kids().push_back( stmt ); - - // add declarations after to new compound statement - for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - compound->get_kids().push_back( declStmt ); - } - declsToAddAfter.back().clear(); - - doEndScope(); - return compound; - } - - void DeclMutator::mutateStatementList( std::list< Statement* > &stmts ) { - doBeginScope(); - - - for ( std::list< Statement* >::iterator stmt = stmts.begin(); ; ++stmt ) { - // add any new declarations after the previous statement - for ( std::list< Declaration* >::iterator decl = declsToAddAfter.back().begin(); decl != declsToAddAfter.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - stmts.insert( stmt, declStmt ); - } - declsToAddAfter.back().clear(); - - if ( stmt == stmts.end() ) break; - - // run mutator on statement - *stmt = maybeMutate( *stmt, *this ); - - // add any new declarations before the statement - for ( std::list< Declaration* >::iterator decl = declsToAdd.back().begin(); decl != declsToAdd.back().end(); ++decl ) { - DeclStmt *declStmt = new DeclStmt( noLabels, *decl ); - stmts.insert( stmt, declStmt ); - } - declsToAdd.back().clear(); - } - - doEndScope(); - } - - void DeclMutator::addDeclaration( Declaration *decl ) { - declsToAdd.back().push_back( decl ); - } - - void DeclMutator::addDeclarationAfter( Declaration *decl ) { - declsToAddAfter.back().push_back( decl ); - } - - CompoundStmt* DeclMutator::mutate(CompoundStmt *compoundStmt) { - mutateStatementList( compoundStmt->get_kids() ); - return compoundStmt; - } - - Statement* DeclMutator::mutate(IfStmt *ifStmt) { - ifStmt->set_condition( maybeMutate( ifStmt->get_condition(), *this ) ); - ifStmt->set_thenPart( mutateStatement( ifStmt->get_thenPart() ) ); - ifStmt->set_elsePart( mutateStatement( ifStmt->get_elsePart() ) ); - return ifStmt; - } - - Statement* DeclMutator::mutate(WhileStmt *whileStmt) { - whileStmt->set_condition( maybeMutate( whileStmt->get_condition(), *this ) ); - whileStmt->set_body( mutateStatement( whileStmt->get_body() ) ); - return whileStmt; - } - - Statement* DeclMutator::mutate(ForStmt *forStmt) { - mutateAll( forStmt->get_initialization(), *this ); - forStmt->set_condition( maybeMutate( forStmt->get_condition(), *this ) ); - forStmt->set_increment( maybeMutate( forStmt->get_increment(), *this ) ); - forStmt->set_body( mutateStatement( forStmt->get_body() ) ); - return forStmt; - } - - Statement* DeclMutator::mutate(SwitchStmt *switchStmt) { - switchStmt->set_condition( maybeMutate( switchStmt->get_condition(), *this ) ); - mutateAll( switchStmt->get_statements(), *this ); - return switchStmt; - } - - Statement* DeclMutator::mutate(CaseStmt *caseStmt) { - caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) ); - mutateAll( caseStmt->get_statements(), *this ); - return caseStmt; - } - - Statement* DeclMutator::mutate(TryStmt *tryStmt) { - tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) ); - mutateAll( tryStmt->get_catchers(), *this ); - tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) ); - return tryStmt; - } - - Statement* DeclMutator::mutate(CatchStmt *catchStmt) { - catchStmt->set_decl( maybeMutate( catchStmt->get_decl(), *this ) ); - catchStmt->set_cond( maybeMutate( catchStmt->get_cond(), *this ) ); - catchStmt->set_body( mutateStatement( catchStmt->get_body() ) ); - return catchStmt; - } -} // namespace GenPoly - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: c/GenPoly/DeclMutator.h =================================================================== --- src/GenPoly/DeclMutator.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ (revision ) @@ -1,71 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// DeclMutator.h -- -// -// Author : Aaron B. Moss -// Created On : Fri Nov 27 14:44:00 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:21:12 2017 -// Update Count : 4 -// - -#pragma once - -#include // for list -#include // for vector - -#include "SynTree/Mutator.h" // for Mutator -#include "SynTree/SynTree.h" // for Visitor Nodes - -namespace GenPoly { - /// Mutates a list of declarations, providing a means of adding new declarations into the list - class DeclMutator : public Mutator { - public: - typedef Mutator Parent; - - DeclMutator(); - virtual ~DeclMutator(); - - using Parent::mutate; - virtual CompoundStmt* mutate(CompoundStmt *compoundStmt); - virtual Statement* mutate(IfStmt *ifStmt); - virtual Statement* mutate(WhileStmt *whileStmt); - virtual Statement* mutate(ForStmt *forStmt); - virtual Statement* mutate(SwitchStmt *switchStmt); - virtual Statement* mutate(CaseStmt *caseStmt); - virtual Statement* mutate(TryStmt *tryStmt); - virtual Statement* mutate(CatchStmt *catchStmt); - - /// Mutates a list of declarations with this visitor - void mutateDeclarationList(std::list< Declaration* >& decls); - - /// Called on entry to a new scope; overriders should call this as a super-class call - virtual void doBeginScope(); - /// Called on exit from a scope; overriders should call this as a super-class call - virtual void doEndScope(); - protected: - /// Mutate a statement that forms its own scope - Statement* mutateStatement( Statement *stmt ); - /// Mutate a list of statements that form a scope - void mutateStatementList( std::list< Statement* > &stmts ); - /// Add a declaration to the list to be added before the current position - void addDeclaration( Declaration* decl ); - /// Add a declaration to the list to be added after the current position - void addDeclarationAfter( Declaration* decl ); - private: - /// A stack of declarations to add before the current declaration or statement - std::vector< std::list< Declaration* > > declsToAdd; - /// A stack of declarations to add after the current declaration or statement - std::vector< std::list< Declaration* > > declsToAddAfter; - }; -} // namespace - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: c/GenPoly/PolyMutator.cc =================================================================== --- src/GenPoly/PolyMutator.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ (revision ) @@ -1,187 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// PolyMutator.cc -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Andrew Beach -// Last Modified On : Thu Jun 22 13:47:00 2017 -// Update Count : 17 -// - -#include "PolyMutator.h" - -#include "Common/SemanticError.h" // for SemanticError -#include "Common/utility.h" // for ValueGuard -#include "SynTree/Declaration.h" // for Declaration, TypeDecl, TypeDecl::Data -#include "SynTree/Expression.h" // for Expression, UntypedExpr, StmtExpr ... -#include "SynTree/Initializer.h" // for SingleInit, Initializer (ptr only) -#include "SynTree/Label.h" // for Label, noLabels -#include "SynTree/Mutator.h" // for maybeMutate, mutateAll -#include "SynTree/Statement.h" // for CatchStmt, CompoundStmt, ForStmt - -class TypeSubstitution; - -namespace GenPoly { - PolyMutator::PolyMutator() : scopeTyVars( TypeDecl::Data{} ), env( 0 ) {} - - void PolyMutator::mutateStatementList( std::list< Statement* > &statements ) { - SemanticError errors; - - for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) { - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( i, stmtsToAddAfter ); - } // if - try { - *i = (*i)->acceptMutator( *this ); - } catch ( SemanticError &e ) { - errors.append( e ); - } // try - if ( ! stmtsToAdd.empty() ) { - statements.splice( i, stmtsToAdd ); - } // if - } // for - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( statements.end(), stmtsToAddAfter ); - } // if - if ( ! errors.isEmpty() ) { - throw errors; - } - } - - Statement * PolyMutator::mutateStatement( Statement *stmt ) { - // don't want statements from outer CompoundStmts to be added to this CompoundStmt - ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd ); - ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter ); - ValueGuard< TypeSubstitution * > oldEnv( env ); - stmtsToAdd.clear(); - stmtsToAddAfter.clear(); - - Statement *newStmt = maybeMutate( stmt, *this ); - if ( ! stmtsToAdd.empty() || ! stmtsToAddAfter.empty() ) { - CompoundStmt *compound = new CompoundStmt( noLabels ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAdd ); - compound->get_kids().push_back( newStmt ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAddAfter ); - // doEndScope(); - return compound; - } else { - return newStmt; - } - } - - Expression * PolyMutator::mutateExpression( Expression *expr ) { - if ( expr ) { - if ( expr->get_env() ) { - env = expr->get_env(); - } - // xxx - should env be cloned (or moved) onto the result of the mutate? - return expr->acceptMutator( *this ); - } else { - return expr; - } - } - - CompoundStmt * PolyMutator::mutate(CompoundStmt *compoundStmt) { - doBeginScope(); - mutateStatementList( compoundStmt->get_kids() ); - doEndScope(); - return compoundStmt; - } - - Statement * PolyMutator::mutate(IfStmt *ifStmt) { - ifStmt->set_condition( mutateExpression( ifStmt->get_condition() ) ); - ifStmt->set_thenPart( mutateStatement( ifStmt->get_thenPart() ) ); - ifStmt->set_elsePart( mutateStatement( ifStmt->get_elsePart() ) ); - return ifStmt; - } - - Statement * PolyMutator::mutate(WhileStmt *whileStmt) { - whileStmt->set_condition( mutateExpression( whileStmt->get_condition() ) ); - whileStmt->set_body( mutateStatement( whileStmt->get_body() ) ); - return whileStmt; - } - - Statement * PolyMutator::mutate(ForStmt *forStmt) { - mutateAll( forStmt->get_initialization(), *this ); - forStmt->set_condition( mutateExpression( forStmt->get_condition() ) ); - forStmt->set_increment( mutateExpression( forStmt->get_increment() ) ); - forStmt->set_body( mutateStatement( forStmt->get_body() ) ); - return forStmt; - } - - Statement * PolyMutator::mutate(SwitchStmt *switchStmt) { - switchStmt->set_condition( mutateExpression( switchStmt->get_condition() ) ); - mutateStatementList( switchStmt->get_statements() ); - return switchStmt; - } - - Statement * PolyMutator::mutate(CaseStmt *caseStmt) { - caseStmt->set_condition( mutateExpression( caseStmt->get_condition() ) ); - mutateStatementList( caseStmt->get_statements() ); - return caseStmt; - } - - Statement * PolyMutator::mutate(TryStmt *tryStmt) { - tryStmt->set_block( maybeMutate( tryStmt->get_block(), *this ) ); - mutateAll( tryStmt->get_catchers(), *this ); - tryStmt->set_finally( maybeMutate( tryStmt->get_finally(), *this ) ); - return tryStmt; - } - - Statement * PolyMutator::mutate(CatchStmt *cathStmt) { - cathStmt->set_body( mutateStatement( cathStmt->get_body() ) ); - cathStmt->set_cond( maybeMutate( cathStmt->get_cond(), *this ) ); - cathStmt->set_decl( maybeMutate( cathStmt->get_decl(), *this ) ); - return cathStmt; - } - - Statement * PolyMutator::mutate(ReturnStmt *retStmt) { - retStmt->set_expr( mutateExpression( retStmt->get_expr() ) ); - return retStmt; - } - - Statement * PolyMutator::mutate(ExprStmt *exprStmt) { - exprStmt->set_expr( mutateExpression( exprStmt->get_expr() ) ); - return exprStmt; - } - - - Expression * PolyMutator::mutate(UntypedExpr *untypedExpr) { - for ( std::list< Expression* >::iterator i = untypedExpr->get_args().begin(); i != untypedExpr->get_args().end(); ++i ) { - *i = mutateExpression( *i ); - } // for - return untypedExpr; - } - - Expression *PolyMutator::mutate( StmtExpr * stmtExpr ) { - // don't want statements from outer CompoundStmts to be added to this StmtExpr - ValueGuard< std::list< Statement* > > oldStmtsToAdd( stmtsToAdd ); - ValueGuard< std::list< Statement* > > oldStmtsToAddAfter( stmtsToAddAfter ); - ValueGuard< TypeSubstitution * > oldEnv( env ); - - // xxx - not sure if this is needed, along with appropriate reset, but I don't think so... - // ValueGuard< TyVarMap > oldScopeTyVars( scopeTyVars ); - - stmtsToAdd.clear(); - stmtsToAddAfter.clear(); - // scopeTyVars.clear(); - - return Parent::mutate( stmtExpr ); - } - - Initializer *PolyMutator::mutate( SingleInit *singleInit ) { - singleInit->set_value( mutateExpression( singleInit->get_value() ) ); - return singleInit; - } -} // namespace GenPoly - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: c/GenPoly/PolyMutator.h =================================================================== --- src/GenPoly/PolyMutator.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ (revision ) @@ -1,67 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// PolyMutator.h -- -// -// Author : Richard C. Bilson -// Created On : Mon May 18 07:44:20 2015 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:20:31 2017 -// Update Count : 7 -// - -#pragma once - -#include // for list - -#include "GenPoly.h" // for TyVarMap -#include "SynTree/Mutator.h" // for Mutator -#include "SynTree/SynTree.h" // for Visitor Nodes - -namespace GenPoly { - class PolyMutator : public Mutator { - public: - typedef Mutator Parent; - using Parent::mutate; - - PolyMutator(); - - virtual CompoundStmt* mutate(CompoundStmt *compoundStmt); - virtual Statement* mutate(IfStmt *ifStmt); - virtual Statement* mutate(WhileStmt *whileStmt); - virtual Statement* mutate(ForStmt *forStmt); - virtual Statement* mutate(SwitchStmt *switchStmt); - virtual Statement* mutate(CaseStmt *caseStmt); - virtual Statement* mutate(TryStmt *returnStmt); - virtual Statement* mutate(CatchStmt *catchStmt); - virtual Statement* mutate(ExprStmt *catchStmt); - virtual Statement* mutate(ReturnStmt *catchStmt); - - virtual Expression* mutate(UntypedExpr *untypedExpr); - virtual Expression* mutate( StmtExpr *stmtExpr ); - - virtual Initializer* mutate(SingleInit *SingleInit); - - // template method - virtual void doBeginScope() {} - virtual void doEndScope() {} - protected: - void mutateStatementList( std::list< Statement* > &statements ); - Statement* mutateStatement( Statement *stmt ); - Expression* mutateExpression( Expression *expr ); - - TyVarMap scopeTyVars; - TypeSubstitution *env; - std::list< Statement* > stmtsToAdd; - std::list< Statement* > stmtsToAddAfter; - }; -} // namespace - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/GenPoly/Specialize.cc =================================================================== --- src/GenPoly/Specialize.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/GenPoly/Specialize.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -22,4 +22,5 @@ #include // for pair +#include "Common/PassVisitor.h" #include "Common/SemanticError.h" // for SemanticError #include "Common/UniqueName.h" // for UniqueName @@ -28,5 +29,4 @@ #include "InitTweak/InitTweak.h" // for isIntrinsicCallExpr #include "Parser/LinkageSpec.h" // for C -#include "PolyMutator.h" // for PolyMutator #include "ResolvExpr/FindOpenVars.h" // for findOpenVars #include "ResolvExpr/TypeEnvironment.h" // for OpenVarSet, AssertionSet @@ -43,13 +43,8 @@ namespace GenPoly { - class Specialize final : public PolyMutator { - public: - using PolyMutator::mutate; - virtual Expression * mutate( ApplicationExpr *applicationExpr ) override; - virtual Expression * mutate( AddressExpr *castExpr ) override; - virtual Expression * mutate( CastExpr *castExpr ) override; - // virtual Expression * mutate( LogicalExpr *logicalExpr ); - // virtual Expression * mutate( ConditionalExpr *conditionalExpr ); - // virtual Expression * mutate( CommaExpr *commaExpr ); + struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef { + Expression * postmutate( ApplicationExpr *applicationExpr ); + Expression * postmutate( AddressExpr *castExpr ); + Expression * postmutate( CastExpr *castExpr ); void handleExplicitParams( ApplicationExpr *appExpr ); @@ -204,11 +199,11 @@ } - struct EnvTrimmer : public Visitor { + struct EnvTrimmer { TypeSubstitution * env, * newEnv; EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){} - virtual void visit( TypeDecl * tyDecl ) { + void previsit( TypeDecl * tyDecl ) { // transfer known bindings for seen type variables - if ( Type * t = env->lookup( tyDecl->get_name() ) ) { - newEnv->add( tyDecl->get_name(), t ); + if ( Type * t = env->lookup( tyDecl->name ) ) { + newEnv->add( tyDecl->name, t ); } } @@ -219,5 +214,5 @@ if ( env ) { TypeSubstitution * newEnv = new TypeSubstitution(); - EnvTrimmer trimmer( env, newEnv ); + PassVisitor trimmer( env, newEnv ); expr->accept( trimmer ); return newEnv; @@ -277,25 +272,25 @@ std::string oldParamPrefix = paramPrefix; paramPrefix += "p"; - // save stmtsToAdd in oldStmts + // save stmtsToAddBefore in oldStmts std::list< Statement* > oldStmts; - oldStmts.splice( oldStmts.end(), stmtsToAdd ); - mutate( appExpr ); + oldStmts.splice( oldStmts.end(), stmtsToAddBefore ); + appExpr->acceptMutator( *visitor ); paramPrefix = oldParamPrefix; // write any statements added for recursive specializations into the thunk body - thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd ); - // restore oldStmts into stmtsToAdd - stmtsToAdd.splice( stmtsToAdd.end(), oldStmts ); + thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore ); + // restore oldStmts into stmtsToAddBefore + stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts ); // add return (or valueless expression) to the thunk Statement *appStmt; - if ( funType->get_returnVals().empty() ) { + if ( funType->returnVals.empty() ) { appStmt = new ExprStmt( noLabels, appExpr ); } else { appStmt = new ReturnStmt( noLabels, appExpr ); } // if - thunkFunc->get_statements()->get_kids().push_back( appStmt ); + thunkFunc->statements->kids.push_back( appStmt ); // add thunk definition to queue of statements to add - stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) ); // return address of thunk function as replacement expression return new AddressExpr( new VariableExpr( thunkFunc ) ); @@ -304,18 +299,15 @@ void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) { // create thunks for the explicit parameters - assert( appExpr->get_function()->has_result() ); - FunctionType *function = getFunctionType( appExpr->get_function()->get_result() ); + assert( appExpr->function->result ); + FunctionType *function = getFunctionType( appExpr->function->result ); assert( function ); std::list< DeclarationWithType* >::iterator formal; std::list< Expression* >::iterator actual; for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) { - *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() ); - } - } - - Expression * Specialize::mutate( ApplicationExpr *appExpr ) { - appExpr->get_function()->acceptMutator( *this ); - mutateAll( appExpr->get_args(), *this ); - + *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() ); + } + } + + Expression * Specialize::postmutate( ApplicationExpr *appExpr ) { if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) { // create thunks for the inferred parameters @@ -331,19 +323,17 @@ } - Expression * Specialize::mutate( AddressExpr *addrExpr ) { - addrExpr->get_arg()->acceptMutator( *this ); - assert( addrExpr->has_result() ); - addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) ); + Expression * Specialize::postmutate( AddressExpr *addrExpr ) { + assert( addrExpr->result ); + addrExpr->set_arg( doSpecialization( addrExpr->result, addrExpr->arg ) ); return addrExpr; } - Expression * Specialize::mutate( CastExpr *castExpr ) { - castExpr->get_arg()->acceptMutator( *this ); - if ( castExpr->get_result()->isVoid() ) { + Expression * Specialize::postmutate( CastExpr *castExpr ) { + if ( castExpr->result->isVoid() ) { // can't specialize if we don't have a return value return castExpr; } - Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() ); - if ( specialized != castExpr->get_arg() ) { + Expression *specialized = doSpecialization( castExpr->result, castExpr->arg ); + if ( specialized != castExpr->arg ) { // assume here that the specialization incorporates the cast return specialized; @@ -353,22 +343,6 @@ } - // Removing these for now. Richard put these in for some reason, but it's not clear why. - // In particular, copy constructors produce a comma expression, and with this code the parts - // of that comma expression are not specialized, which causes problems. - - // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) { - // return logicalExpr; - // } - - // Expression * Specialize::mutate( ConditionalExpr *condExpr ) { - // return condExpr; - // } - - // Expression * Specialize::mutate( CommaExpr *commaExpr ) { - // return commaExpr; - // } - void convertSpecializations( std::list< Declaration* >& translationUnit ) { - Specialize spec; + PassVisitor spec; mutateAll( translationUnit, spec ); } Index: src/GenPoly/module.mk =================================================================== --- src/GenPoly/module.mk (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/GenPoly/module.mk (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -6,5 +6,5 @@ ## file "LICENCE" distributed with Cforall. ## -## module.mk -- +## module.mk -- ## ## Author : Richard C. Bilson @@ -17,5 +17,4 @@ SRC += GenPoly/Box.cc \ GenPoly/GenPoly.cc \ - GenPoly/PolyMutator.cc \ GenPoly/ScrubTyVars.cc \ GenPoly/Lvalue.cc \ @@ -23,4 +22,3 @@ GenPoly/CopyParams.cc \ GenPoly/FindFunction.cc \ - GenPoly/DeclMutator.cc \ GenPoly/InstantiateGeneric.cc Index: src/InitTweak/FixInit.cc =================================================================== --- src/InitTweak/FixInit.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/InitTweak/FixInit.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -36,7 +36,5 @@ #include "FixGlobalInit.h" // for fixGlobalInit #include "GenInit.h" // for genCtorDtor -#include "GenPoly/DeclMutator.h" // for DeclMutator #include "GenPoly/GenPoly.h" // for getFunctionType -#include "GenPoly/PolyMutator.h" // for PolyMutator #include "InitTweak.h" // for getFunctionName, getCallArg #include "Parser/LinkageSpec.h" // for C, Spec, Cforall, isBuiltin @@ -46,5 +44,4 @@ #include "SymTab/Indexer.h" // for Indexer #include "SymTab/Mangler.h" // for Mangler -#include "SynTree/AddStmtVisitor.h" // for AddStmtVisitor #include "SynTree/Attribute.h" // for Attribute #include "SynTree/Constant.h" // for Constant @@ -58,5 +55,4 @@ #include "SynTree/TypeSubstitution.h" // for TypeSubstitution, operator<< #include "SynTree/Visitor.h" // for acceptAll, maybeAccept -#include "Tuples/Tuples.h" // for isTtype bool ctordtorp = false; // print all debug @@ -187,5 +183,5 @@ }; - class FixCopyCtors final : public GenPoly::PolyMutator { + class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef { public: FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){} @@ -194,9 +190,7 @@ static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount ); - typedef GenPoly::PolyMutator Parent; - using Parent::mutate; - virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override; - virtual Expression * mutate( UniqueExpr * unqExpr ) override; - virtual Expression * mutate( StmtExpr * stmtExpr ) override; + Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ); + void premutate( StmtExpr * stmtExpr ); + void premutate( UniqueExpr * unqExpr ); UnqCount & unqCount; @@ -243,11 +237,9 @@ }; - class FixCtorExprs final : public GenPoly::DeclMutator { - public: + struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer { /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument static void fix( std::list< Declaration * > & translationUnit ); - using GenPoly::DeclMutator::mutate; - virtual Expression * mutate( ConstructorExpr * ctorExpr ) override; + Expression * postmutate( ConstructorExpr * ctorExpr ); }; } // namespace @@ -316,5 +308,5 @@ void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) { - FixCopyCtors fixer( unqCount ); + PassVisitor fixer( unqCount ); mutateAll( translationUnit, fixer ); } @@ -326,6 +318,6 @@ void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) { - FixCtorExprs fixer; - fixer.mutateDeclarationList( translationUnit ); + PassVisitor fixer; + mutateAll( translationUnit, fixer ); } @@ -339,5 +331,5 @@ } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) { FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) ); - assert( ftype ); + assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() ); if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) { Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() ); @@ -368,7 +360,5 @@ } - bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { - return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type ); - } + bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); } Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) { @@ -407,5 +397,5 @@ result = result->clone(); env->apply( result ); - ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 ); + ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr ); tmp->get_type()->set_const( false ); @@ -421,4 +411,7 @@ if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return; } + + // set a unique name for the temporary once it's certain the call is necessary + tmp->name = tempNamer.newName(); // replace argument to function call with temporary @@ -450,10 +443,10 @@ result = result->clone(); env->apply( result ); - ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 ); + ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr ); ret->get_type()->set_const( false ); impCpCtorExpr->get_returnDecls().push_back( ret ); CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; ) if ( ! dynamic_cast< ReferenceType * >( result ) ) { - // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary + // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary destructRet( ret, impCpCtorExpr ); } @@ -472,5 +465,5 @@ result = result->clone(); env->apply( result ); - ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 ); + ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr ); ret->get_type()->set_const( false ); stmtExpr->get_returnDecls().push_front( ret ); @@ -509,5 +502,5 @@ } else { // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression - unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) ); + unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), nullptr ) ); unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) ); } @@ -515,8 +508,7 @@ } - Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) { + Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) { CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; ) - impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) ); std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls(); std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls(); @@ -525,8 +517,8 @@ // add all temporary declarations and their constructors for ( ObjectDecl * obj : tempDecls ) { - stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) ); } // for for ( ObjectDecl * obj : returnDecls ) { - stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) ); } // for @@ -536,5 +528,4 @@ } // for - // xxx - update to work with multiple return values ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front(); Expression * callExpr = impCpCtorExpr->get_callExpr(); @@ -569,21 +560,23 @@ } - Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) { + void FixCopyCtors::premutate( StmtExpr * stmtExpr ) { // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression, // since temporaries can be shared across sub-expressions, e.g. // [A, A] f(); // g([A] x, [A] y); - // f(g()); + // g(f()); // f is executed once, so the return temporary is shared across the tuple constructors for x and y. + // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added + // to the outer context, rather than inside of the statement expression. + visit_children = false; std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids(); for ( Statement *& stmt : stmts ) { - stmt = stmt->acceptMutator( *this ); + stmt = stmt->acceptMutator( *visitor ); } // for - // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) ); assert( stmtExpr->get_result() ); Type * result = stmtExpr->get_result(); if ( ! result->isVoid() ) { for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) { - stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) ); + stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) ); } // for // add destructors after current statement @@ -592,8 +585,7 @@ } // for // must have a non-empty body, otherwise it wouldn't have a result - CompoundStmt * body = stmtExpr->get_statements(); - assert( ! body->get_kids().empty() ); + assert( ! stmts.empty() ); assert( ! stmtExpr->get_returnDecls().empty() ); - body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) ); + stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) ); stmtExpr->get_returnDecls().clear(); stmtExpr->get_dtors().clear(); @@ -601,12 +593,11 @@ assert( stmtExpr->get_returnDecls().empty() ); assert( stmtExpr->get_dtors().empty() ); - return stmtExpr; - } - - Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) { + } + + void FixCopyCtors::premutate( UniqueExpr * unqExpr ) { + visit_children = false; unqCount[ unqExpr->get_id() ]--; static std::unordered_map< int, std::list< Statement * > > dtors; static std::unordered_map< int, UniqueExpr * > unqMap; - static std::unordered_set< int > addDeref; // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes if ( unqMap.count( unqExpr->get_id() ) ) { @@ -619,30 +610,16 @@ stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] ); } - if ( addDeref.count( unqExpr->get_id() ) ) { - // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too - return UntypedExpr::createDeref( unqExpr ); - } - return unqExpr; - } - FixCopyCtors fixer( unqCount ); + return; + } + PassVisitor fixer( unqCount ); unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup - stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd ); + stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore ); unqMap[unqExpr->get_id()] = unqExpr; if ( unqCount[ unqExpr->get_id() ] == 0 ) { // insert destructor after the last use of the unique expression stmtsToAddAfter.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. - // Normalize the expression by dereferencing the unique expression, rather than the inner expression - // (i.e. move the dereference out a level) - assert( getFunctionName( deref ) == "*?" ); - unqExpr->set_expr( getCallArg( deref, 0 ) ); - getCallArg( deref, 0 ) = unqExpr; - addDeref.insert( unqExpr->get_id() ); - return deref; - } - return unqExpr; + dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter; + } + return; } @@ -819,7 +796,9 @@ assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() ); Statement * dtor = ctorInit->get_dtor(); + // don't need to call intrinsic dtor, because it does nothing, but + // non-intrinsic dtors must be called if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) { - // don't need to call intrinsic dtor, because it does nothing, but - // non-intrinsic dtors must be called + // set dtor location to the object's location for error messages + ctorInit->dtor->location = objDecl->location; reverseDeclOrder.front().push_front( objDecl ); } // if @@ -1012,4 +991,6 @@ // skip non-DWT members if ( ! field ) continue; + // skip non-constructable members + if ( ! tryConstruct( field ) ) continue; // skip handled members if ( ! unhandled.count( field ) ) continue; @@ -1142,5 +1123,5 @@ } - Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) { + Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) { static UniqueName tempNamer( "_tmp_ctor_expr" ); // xxx - is the size check necessary? @@ -1148,6 +1129,6 @@ // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary. - ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr ); - addDeclaration( tmp ); + ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr ); + declsToAddBefore.push_back( tmp ); // xxx - this can be TupleAssignExpr now. Need to properly handle this case. @@ -1158,26 +1139,14 @@ delete ctorExpr; + // build assignment and replace constructor's first argument with new temporary Expression *& firstArg = callExpr->get_args().front(); - - // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away. - - // generate the type of assignment operator using the type of tmp minus any reference types - Type * type = tmp->get_type()->stripReferences(); - FunctionType * ftype = SymTab::genAssignType( type ); - - // generate fake assignment decl and call it using &tmp and &firstArg - // since tmp is guaranteed to be a reference and we want to assign pointers - FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr ); - ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) ); - assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) ); - Expression * addrArg = new AddressExpr( firstArg ); - // if firstArg has type T&&, then &firstArg has type T*&. - // Cast away the reference to a value type so that the argument - // matches the assignment's parameter types - if ( dynamic_cast( addrArg->get_result() ) ) { - addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() ); - } - assign->get_args().push_back( addrArg ); + Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } ); firstArg = new VariableExpr( tmp ); + + // resolve assignment and dispose of new env + Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer ); + delete resolvedAssign->env; + resolvedAssign->env = nullptr; + delete assign; // for constructor expr: @@ -1188,5 +1157,5 @@ // T & tmp; // &tmp = &x, ?{}(tmp), tmp - CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) ); + CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) ); commaExpr->set_env( env ); return commaExpr; Index: src/InitTweak/GenInit.cc =================================================================== --- src/InitTweak/GenInit.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/InitTweak/GenInit.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -26,5 +26,4 @@ #include "Common/UniqueName.h" // for UniqueName #include "Common/utility.h" // for ValueGuard, maybeClone -#include "GenPoly/DeclMutator.h" // for DeclMutator #include "GenPoly/GenPoly.h" // for getFunctionType, isPolyType #include "GenPoly/ScopedSet.h" // for ScopedSet, ScopedSet<>::const_iter... @@ -62,5 +61,5 @@ }; - struct CtorDtor : public WithGuards, public WithShortCircuiting { + struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef { /// create constructor and destructor statements for object declarations. /// the actual call statements will be added in after the resolver has run @@ -75,10 +74,7 @@ // that need to be constructed or destructed void previsit( StructDecl *aggregateDecl ); - void previsit( __attribute__((unused)) UnionDecl * aggregateDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) EnumDecl * aggregateDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) TraitDecl * aggregateDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) TypeDecl * typeDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) TypedefDecl * typeDecl ) { visit_children = false; } - void previsit( __attribute__((unused)) FunctionType * funcType ) { visit_children = false; } + void previsit( AggregateDecl * ) { visit_children = false; } + void previsit( NamedTypeDecl * ) { visit_children = false; } + void previsit( FunctionType * ) { visit_children = false; } void previsit( CompoundStmt * compoundStmt ); @@ -96,8 +92,5 @@ }; - class HoistArrayDimension final : public GenPoly::DeclMutator { - public: - typedef GenPoly::DeclMutator Parent; - + struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards { /// hoist dimension from array types in object declaration so that it uses a single /// const variable of type size_t, so that side effecting array dimensions are only @@ -105,19 +98,12 @@ static void hoistArrayDimension( std::list< Declaration * > & translationUnit ); - private: - using Parent::mutate; - - virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override; - virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override; + void premutate( ObjectDecl * objectDecl ); + DeclarationWithType * postmutate( ObjectDecl * objectDecl ); + void premutate( FunctionDecl *functionDecl ); // should not traverse into any of these declarations to find objects // that need to be constructed or destructed - virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; } - virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; } - virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; } - virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; } - - virtual Type* mutate( FunctionType *funcType ) override { return funcType; } + void premutate( AggregateDecl * ) { visit_children = false; } + void premutate( NamedTypeDecl * ) { visit_children = false; } + void premutate( FunctionType * ) { visit_children = false; } void hoist( Type * type ); @@ -128,10 +114,10 @@ void genInit( std::list< Declaration * > & translationUnit ) { - ReturnFixer::makeReturnTemp( translationUnit ); + fixReturnStatements( translationUnit ); HoistArrayDimension::hoistArrayDimension( translationUnit ); CtorDtor::generateCtorDtor( translationUnit ); } - void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) { + void fixReturnStatements( std::list< Declaration * > & translationUnit ) { PassVisitor fixer; mutateAll( translationUnit, fixer ); @@ -143,5 +129,5 @@ // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address // is being returned - if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) { + if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) { // 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() ); @@ -158,6 +144,6 @@ GuardValue( funcName ); - ftype = functionDecl->get_functionType(); - funcName = functionDecl->get_name(); + ftype = functionDecl->type; + funcName = functionDecl->name; } @@ -165,13 +151,16 @@ // which would be incorrect if it is a side-effecting computation. void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) { - HoistArrayDimension hoister; - hoister.mutateDeclarationList( translationUnit ); - } - - DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) { + PassVisitor hoister; + mutateAll( translationUnit, hoister ); + } + + void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) { + GuardValue( storageClasses ); storageClasses = objectDecl->get_storageClasses(); - DeclarationWithType * temp = Parent::mutate( objectDecl ); + } + + DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) { hoist( objectDecl->get_type() ); - return temp; + return objectDecl; } @@ -194,5 +183,5 @@ arrayType->set_dimension( new VariableExpr( arrayDimension ) ); - addDeclaration( arrayDimension ); + declsToAddBefore.push_back( arrayDimension ); hoist( arrayType->get_base() ); @@ -201,9 +190,6 @@ } - DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) { - ValueGuard< bool > oldInFunc( inFunction ); - inFunction = true; - DeclarationWithType * decl = Parent::mutate( functionDecl ); - return decl; + void HoistArrayDimension::premutate( FunctionDecl * ) { + GuardValue( inFunction ); } @@ -214,5 +200,5 @@ bool CtorDtor::isManaged( Type * type ) const { - // at least for now, references are never constructed + // references are never constructed if ( dynamic_cast< ReferenceType * >( type ) ) return false; // need to clear and reset qualifiers when determining if a type is managed @@ -221,5 +207,5 @@ if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) { // tuple is also managed if any of its components are managed - if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) { + if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) { return true; } @@ -305,4 +291,5 @@ void CtorDtor::previsit( FunctionDecl *functionDecl ) { + visit_children = false; // do not try and construct parameters or forall parameters GuardValue( inFunction ); inFunction = true; @@ -318,8 +305,5 @@ } - PassVisitor newCtorDtor; - newCtorDtor.pass = *this; - maybeAccept( functionDecl->get_statements(), newCtorDtor ); - visit_children = false; // do not try and construct parameters or forall parameters - must happen after maybeAccept + maybeAccept( functionDecl->get_statements(), *visitor ); } @@ -340,5 +324,5 @@ } - void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) { + void CtorDtor::previsit( CompoundStmt * ) { GuardScope( managedTypes ); } Index: src/InitTweak/GenInit.h =================================================================== --- src/InitTweak/GenInit.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/InitTweak/GenInit.h (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -25,6 +25,9 @@ void genInit( std::list< Declaration * > & translationUnit ); - /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument - ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr ); + /// Converts return statements into copy constructor calls on the hidden return variable + void fixReturnStatements( std::list< Declaration * > & translationUnit ); + + /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument + ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr ); /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer Index: src/InitTweak/InitTweak.cc =================================================================== --- src/InitTweak/InitTweak.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/InitTweak/InitTweak.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -1,3 +1,2 @@ -#include // for NULL #include // for find, all_of #include // for assertf, assert, strict_dynamic_cast @@ -23,4 +22,5 @@ #include "SynTree/Type.h" // for FunctionType, ArrayType, PointerType #include "SynTree/Visitor.h" // for Visitor, maybeAccept +#include "Tuples/Tuples.h" // for Tuples::isTtype class UntypedValofExpr; @@ -184,5 +184,5 @@ callExpr->get_args().splice( callExpr->get_args().end(), args ); - *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL ); + *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr ); UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) ); @@ -250,18 +250,18 @@ // To accomplish this, generate switch statement, consuming all of expander's elements Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) { - if ( ! init ) return NULL; + if ( ! init ) return nullptr; CompoundStmt * block = new CompoundStmt( noLabels ); build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) ); if ( block->get_kids().empty() ) { delete block; - return NULL; + return nullptr; } else { - init = NULL; // init was consumed in creating the list init + init = nullptr; // init was consumed in creating the list init return block; } } - Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) { - return NULL; + Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) { + return nullptr; } @@ -270,9 +270,16 @@ } - bool tryConstruct( ObjectDecl * objDecl ) { + bool tryConstruct( DeclarationWithType * dwt ) { + ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt ); + if ( ! objDecl ) return false; return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) && - (objDecl->get_init() == NULL || - ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() )) - && ! objDecl->get_storageClasses().is_extern; + (objDecl->get_init() == nullptr || + ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() )) + && ! objDecl->get_storageClasses().is_extern + && isConstructable( objDecl->type ); + } + + bool isConstructable( Type * type ) { + return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type ); } @@ -314,5 +321,5 @@ collectCtorDtorCalls( stmt, matches ); assert( matches.size() <= 1 ); - return matches.size() == 1 ? matches.front() : NULL; + return matches.size() == 1 ? matches.front() : nullptr; } @@ -359,10 +366,10 @@ ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) { ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr ); - if ( ! appExpr ) return NULL; + if ( ! appExpr ) return nullptr; DeclarationWithType * function = getCalledFunction( appExpr->get_function() ); assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() ); // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor // will call all member dtors, and some members may have a user defined dtor. - return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL; + return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr; } @@ -482,5 +489,5 @@ return refType->get_base(); } else { - return NULL; + return nullptr; } } @@ -488,5 +495,5 @@ Type * isPointerType( Type * type ) { if ( getPointerBase( type ) ) return type; - else return NULL; + else return nullptr; } Index: src/InitTweak/InitTweak.h =================================================================== --- src/InitTweak/InitTweak.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/InitTweak/InitTweak.h (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -33,6 +33,9 @@ std::list< Expression * > makeInitList( Initializer * init ); - /// True if the resolver should try to construct objDecl - bool tryConstruct( ObjectDecl * objDecl ); + /// True if the resolver should try to construct dwt + bool tryConstruct( DeclarationWithType * dwt ); + + /// True if the type can have a user-defined constructor + bool isConstructable( Type * t ); /// True if the Initializer contains designations Index: src/Makefile.in =================================================================== --- src/Makefile.in (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/Makefile.in (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -172,5 +172,4 @@ GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \ GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \ - GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) \ GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT) \ GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) \ @@ -178,5 +177,4 @@ GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \ GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \ - GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \ GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \ InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \ @@ -253,5 +251,4 @@ SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) \ SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \ - SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT) \ SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \ SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \ @@ -497,8 +494,7 @@ ControlStruct/ForExprMutator.cc \ ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \ - GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \ - GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \ - GenPoly/CopyParams.cc GenPoly/FindFunction.cc \ - GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \ + GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \ + GenPoly/Specialize.cc GenPoly/CopyParams.cc \ + GenPoly/FindFunction.cc GenPoly/InstantiateGeneric.cc \ InitTweak/GenInit.cc InitTweak/FixInit.cc \ InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \ @@ -535,8 +531,8 @@ SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \ SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \ - SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \ - SynTree/Attribute.cc SynTree/VarExprReplacer.cc \ - Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \ - Tuples/Explode.cc Virtual/ExpandCasts.cc + SynTree/TypeSubstitution.cc SynTree/Attribute.cc \ + SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \ + Tuples/TupleExpansion.cc Tuples/Explode.cc \ + Virtual/ExpandCasts.cc MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \ ${cfa_cpplib_PROGRAMS}} @@ -717,6 +713,4 @@ GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \ GenPoly/$(DEPDIR)/$(am__dirstamp) -GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \ - GenPoly/$(DEPDIR)/$(am__dirstamp) GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT): GenPoly/$(am__dirstamp) \ GenPoly/$(DEPDIR)/$(am__dirstamp) @@ -729,6 +723,4 @@ GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT): \ GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp) -GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \ - GenPoly/$(DEPDIR)/$(am__dirstamp) GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT): \ GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp) @@ -929,6 +921,4 @@ SynTree/driver_cfa_cpp-Mutator.$(OBJEXT): SynTree/$(am__dirstamp) \ SynTree/$(DEPDIR)/$(am__dirstamp) -SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT): \ - SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT): \ SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp) @@ -1008,10 +998,8 @@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Specialize.Po@am__quote@ @@ -1056,5 +1044,4 @@ @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@ -@AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AggregateDecl.Po@am__quote@ @@ -1450,18 +1437,4 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-GenPoly.obj `if test -f 'GenPoly/GenPoly.cc'; then $(CYGPATH_W) 'GenPoly/GenPoly.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/GenPoly.cc'; fi` -GenPoly/driver_cfa_cpp-PolyMutator.o: GenPoly/PolyMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc - -GenPoly/driver_cfa_cpp-PolyMutator.obj: GenPoly/PolyMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi` - GenPoly/driver_cfa_cpp-ScrubTyVars.o: GenPoly/ScrubTyVars.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-ScrubTyVars.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Tpo -c -o GenPoly/driver_cfa_cpp-ScrubTyVars.o `test -f 'GenPoly/ScrubTyVars.cc' || echo '$(srcdir)/'`GenPoly/ScrubTyVars.cc @@ -1534,18 +1507,4 @@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi` -GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc - -GenPoly/driver_cfa_cpp-DeclMutator.obj: GenPoly/DeclMutator.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi` - GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc @am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc @@ -2583,18 +2542,4 @@ @AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ @am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-Mutator.obj `if test -f 'SynTree/Mutator.cc'; then $(CYGPATH_W) 'SynTree/Mutator.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Mutator.cc'; fi` - -SynTree/driver_cfa_cpp-AddStmtVisitor.o: SynTree/AddStmtVisitor.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.o' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc - -SynTree/driver_cfa_cpp-AddStmtVisitor.obj: SynTree/AddStmtVisitor.cc -@am__fastdepCXX_TRUE@ $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi` -@am__fastdepCXX_TRUE@ $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.obj' libtool=no @AMDEPBACKSLASH@ -@AMDEP_TRUE@@am__fastdepCXX_FALSE@ DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@ -@am__fastdepCXX_FALSE@ $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi` SynTree/driver_cfa_cpp-TypeSubstitution.o: SynTree/TypeSubstitution.cc Index: src/Parser/StatementNode.cc =================================================================== --- src/Parser/StatementNode.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/Parser/StatementNode.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -234,5 +234,5 @@ target, maybeMoveBuild( stmt ), - maybeMoveBuild( when ) + notZeroExpr( maybeMoveBuild( when ) ) }); @@ -250,8 +250,8 @@ delete targetExpr; - node->clauses.push_back( WaitForStmt::Clause{ + node->clauses.insert( node->clauses.begin(), WaitForStmt::Clause{ std::move( target ), maybeMoveBuild( stmt ), - maybeMoveBuild( when ) + notZeroExpr( maybeMoveBuild( when ) ) }); @@ -265,9 +265,9 @@ node->timeout.time = maybeMoveBuild( timeout ); node->timeout.statement = maybeMoveBuild( stmt ); - node->timeout.condition = maybeMoveBuild( when ); + node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); } else { - node->orelse.statement = maybeMoveBuild( stmt ); - node->orelse.condition = maybeMoveBuild( when ); + node->orelse.statement = maybeMoveBuild( stmt ); + node->orelse.condition = notZeroExpr( maybeMoveBuild( when ) ); } @@ -280,17 +280,11 @@ node->timeout.time = maybeMoveBuild( timeout ); node->timeout.statement = maybeMoveBuild( stmt ); - node->timeout.condition = maybeMoveBuild( when ); + node->timeout.condition = notZeroExpr( maybeMoveBuild( when ) ); node->orelse.statement = maybeMoveBuild( else_stmt ); - node->orelse.condition = maybeMoveBuild( else_when ); + node->orelse.condition = notZeroExpr( maybeMoveBuild( else_when ) ); return node; } - -// WaitForStmt::Target build_waitfor( const std::string * name, ExpressionNode * arguments ) { -// return WaitForStmt::Clause{ - -// }; -// } Statement *build_compound( StatementNode *first ) { Index: src/Parser/parserutility.cc =================================================================== --- src/Parser/parserutility.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/Parser/parserutility.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -29,4 +29,5 @@ Expression *notZeroExpr( Expression *orig ) { + if( !orig ) return nullptr; UntypedExpr *comparison = new UntypedExpr( new NameExpr( "?!=?" ) ); comparison->get_args().push_back( orig ); Index: src/ResolvExpr/AlternativeFinder.cc =================================================================== --- src/ResolvExpr/AlternativeFinder.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/ResolvExpr/AlternativeFinder.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -144,12 +144,12 @@ expr->get_result()->accept( global_renamer ); } - - void referenceToRvalueConversion( Expression *& expr ) { - if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) { - // cast away reference from expr - expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() ); - } - } } // namespace + + void referenceToRvalueConversion( Expression *& expr ) { + if ( dynamic_cast< ReferenceType * >( expr->get_result() ) ) { + // cast away reference from expr + expr = new CastExpr( expr, expr->get_result()->stripReferences()->clone() ); + } + } template< typename InputIterator, typename OutputIterator > Index: src/ResolvExpr/AlternativeFinder.h =================================================================== --- src/ResolvExpr/AlternativeFinder.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/ResolvExpr/AlternativeFinder.h (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -50,4 +50,9 @@ const SymTab::Indexer &get_indexer() const { return indexer; } const TypeEnvironment &get_environ() const { return env; } + + /// Runs a new alternative finder on each element in [begin, end) + /// and writes each alternative finder to out. + template< typename InputIterator, typename OutputIterator > + void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ); private: virtual void visit( ApplicationExpr *applicationExpr ); @@ -81,8 +86,4 @@ virtual void visit( StmtExpr *stmtExpr ); virtual void visit( UntypedInitExpr *initExpr ); - /// Runs a new alternative finder on each element in [begin, end) - /// and writes each alternative finder to out. - template< typename InputIterator, typename OutputIterator > - void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out ); /// Adds alternatives for anonymous members @@ -108,4 +109,5 @@ Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ); + void referenceToRvalueConversion( Expression *& expr ); template< typename InputIterator, typename OutputIterator > Index: src/ResolvExpr/Resolver.cc =================================================================== --- src/ResolvExpr/Resolver.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/ResolvExpr/Resolver.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -40,4 +40,5 @@ #include "SynTree/Visitor.h" // for acceptAll, maybeAccept #include "typeops.h" // for extractResultType +#include "Unify.h" // for unify using namespace std; @@ -71,4 +72,5 @@ void previsit( ThrowStmt *throwStmt ); void previsit( CatchStmt *catchStmt ); + void previsit( WaitForStmt * stmt ); void previsit( SingleInit *singleInit ); @@ -93,4 +95,9 @@ PassVisitor resolver; acceptAll( translationUnit, resolver ); + } + + void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) { + PassVisitor resolver( indexer ); + maybeAccept( decl, resolver ); } @@ -116,26 +123,26 @@ } + Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) { + TypeEnvironment env; + AlternativeFinder finder( indexer, env ); + finder.find( untyped ); + #if 0 + if ( finder.get_alternatives().size() != 1 ) { + std::cout << "untyped expr is "; + untyped->print( std::cout ); + std::cout << std::endl << "alternatives are:"; + for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { + i->print( std::cout ); + } // for + } // if + #endif + assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." ); + Alternative &choice = finder.get_alternatives().front(); + Expression *newExpr = choice.expr->clone(); + finishExpr( newExpr, choice.env ); + return newExpr; + } + namespace { - Expression *findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ) { - TypeEnvironment env; - AlternativeFinder finder( indexer, env ); - finder.find( untyped ); -#if 0 - if ( finder.get_alternatives().size() != 1 ) { - std::cout << "untyped expr is "; - untyped->print( std::cout ); - std::cout << std::endl << "alternatives are:"; - for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) { - i->print( std::cout ); - } // for - } // if -#endif - assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." ); - Alternative &choice = finder.get_alternatives().front(); - Expression *newExpr = choice.expr->clone(); - finishExpr( newExpr, choice.env ); - return newExpr; - } - bool isIntegralType( Type *type ) { if ( dynamic_cast< EnumInstType * >( type ) ) { @@ -391,4 +398,207 @@ } + inline void resolveAsIf( Expression *& expr, SymTab::Indexer & indexer ) { + if( !expr ) return; + Expression * newExpr = findSingleExpression( expr, indexer ); + delete expr; + expr = newExpr; + } + + inline void resolveAsType( Expression *& expr, Type * type, SymTab::Indexer & indexer ) { + if( !expr ) return; + Expression * newExpr = findSingleExpression( new CastExpr( expr, type ), indexer ); + delete expr; + expr = newExpr; + } + + template< typename iterator_t > + inline bool advance_to_mutex( iterator_t & it, const iterator_t & end ) { + while( it != end && !(*it)->get_type()->get_mutex() ) { + it++; + } + + return it != end; + } + + void Resolver::previsit( WaitForStmt * stmt ) { + visit_children = false; + + // Resolve all clauses first + for( auto& clause : stmt->clauses ) { + + TypeEnvironment env; + AlternativeFinder funcFinder( indexer, env ); + + // Find all alternatives for a function in canonical form + funcFinder.findWithAdjustment( clause.target.function ); + + if ( funcFinder.get_alternatives().empty() ) { + stringstream ss; + ss << "Use of undeclared indentifier '"; + ss << strict_dynamic_cast( clause.target.function )->name; + ss << "' in call to waitfor"; + throw SemanticError( ss.str() ); + } + + // Find all alternatives for all arguments in canonical form + std::list< AlternativeFinder > argAlternatives; + funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) ); + + // List all combinations of arguments + std::list< AltList > possibilities; + combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) ); + + AltList func_candidates; + std::vector< AltList > args_candidates; + + // For every possible function : + // try matching the arguments to the parameters + // not the other way around because we have more arguments than parameters + SemanticError errors; + for ( Alternative & func : funcFinder.get_alternatives() ) { + try { + PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() ); + if( !pointer ) { + throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() ); + } + + FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() ); + if( !function ) { + throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() ); + } + + + { + auto param = function->parameters.begin(); + auto param_end = function->parameters.end(); + + if( !advance_to_mutex( param, param_end ) ) { + throw SemanticError("candidate function not viable: no mutex parameters\n", function); + } + } + + Alternative newFunc( func ); + // Strip reference from function + referenceToRvalueConversion( newFunc.expr ); + + // For all the set of arguments we have try to match it with the parameter of the current function alternative + for ( auto & argsList : possibilities ) { + + try { + // Declare data structures need for resolution + OpenVarSet openVars; + AssertionSet resultNeed, resultHave; + TypeEnvironment resultEnv; + + // Load type variables from arguemnts into one shared space + simpleCombineEnvironments( argsList.begin(), argsList.end(), resultEnv ); + + // Make sure we don't widen any existing bindings + for ( auto & i : resultEnv ) { + i.allowWidening = false; + } + + // Find any unbound type variables + resultEnv.extractOpenVars( openVars ); + + auto param = function->parameters.begin(); + auto param_end = function->parameters.end(); + + // For every arguments of its set, check if it matches one of the parameter + // The order is important + for( auto & arg : argsList ) { + + // Ignore non-mutex arguments + if( !advance_to_mutex( param, param_end ) ) { + // We ran out of parameters but still have arguments + // this function doesn't match + throw SemanticError("candidate function not viable: too many mutex arguments\n", function); + } + + // Check if the argument matches the parameter type in the current scope + if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) { + // Type doesn't match + stringstream ss; + ss << "candidate function not viable: no known convertion from '"; + arg.expr->get_result()->print( ss ); + ss << "' to '"; + (*param)->get_type()->print( ss ); + ss << "'\n"; + throw SemanticError(ss.str(), function); + } + + param++; + } + + // All arguments match ! + + // Check if parameters are missing + if( advance_to_mutex( param, param_end ) ) { + // We ran out of arguments but still have parameters left + // this function doesn't match + throw SemanticError("candidate function not viable: too few mutex arguments\n", function); + } + + // All parameters match ! + + // Finish the expressions to tie in the proper environments + finishExpr( newFunc.expr, resultEnv ); + for( Alternative & alt : argsList ) { + finishExpr( alt.expr, resultEnv ); + } + + // This is a match store it and save it for later + func_candidates.push_back( newFunc ); + args_candidates.push_back( argsList ); + + } + catch( SemanticError &e ) { + errors.append( e ); + } + } + } + catch( SemanticError &e ) { + errors.append( e ); + } + } + + // Make sure we got the right number of arguments + if( func_candidates.empty() ) { SemanticError top( "No alternatives for function in call to waitfor" ); top.append( errors ); throw top; } + if( args_candidates.empty() ) { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; } + if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor" ); top.append( errors ); throw top; } + if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor" ); top.append( errors ); throw top; } + + + // Swap the results from the alternative with the unresolved values. + // Alternatives will handle deletion on destruction + std::swap( clause.target.function, func_candidates.front().expr ); + for( auto arg_pair : group_iterate( clause.target.arguments, args_candidates.front() ) ) { + std::swap ( std::get<0>( arg_pair), std::get<1>( arg_pair).expr ); + } + + // Resolve the conditions as if it were an IfStmt + // Resolve the statments normally + resolveAsIf( clause.condition, this->indexer ); + clause.statement->accept( *visitor ); + } + + + if( stmt->timeout.statement ) { + // Resolve the timeout as an size_t for now + // Resolve the conditions as if it were an IfStmt + // Resolve the statments normally + resolveAsType( stmt->timeout.time, new BasicType( noQualifiers, BasicType::LongLongUnsignedInt ), this->indexer ); + resolveAsIf ( stmt->timeout.condition, this->indexer ); + stmt->timeout.statement->accept( *visitor ); + } + + if( stmt->orelse.statement ) { + // Resolve the conditions as if it were an IfStmt + // Resolve the statments normally + resolveAsIf( stmt->orelse.condition, this->indexer ); + stmt->orelse.statement->accept( *visitor ); + } + } + template< typename T > bool isCharType( T t ) { Index: src/ResolvExpr/Resolver.h =================================================================== --- src/ResolvExpr/Resolver.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/ResolvExpr/Resolver.h (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -29,6 +29,8 @@ /// Checks types and binds syntactic constructs to typed representations void resolve( std::list< Declaration * > translationUnit ); + void resolveDecl( Declaration *, const SymTab::Indexer &indexer ); Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ); Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer ); + Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer ); void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ); void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ); Index: src/ResolvExpr/TypeEnvironment.cc =================================================================== --- src/ResolvExpr/TypeEnvironment.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/ResolvExpr/TypeEnvironment.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -123,13 +123,13 @@ for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) { for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) { -/// std::cout << "adding " << *theVar; +/// std::cerr << "adding " << *theVar; if ( theClass->type ) { -/// std::cout << " bound to "; -/// theClass->type->print( std::cout ); -/// std::cout << std::endl; +/// std::cerr << " bound to "; +/// theClass->type->print( std::cerr ); +/// std::cerr << std::endl; sub.add( *theVar, theClass->type ); } else if ( theVar != theClass->vars.begin() ) { TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype ); -/// std::cout << " bound to variable " << *theClass->vars.begin() << std::endl; +/// std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl; sub.add( *theVar, newTypeInst ); delete newTypeInst; Index: src/SymTab/Autogen.cc =================================================================== --- src/SymTab/Autogen.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SymTab/Autogen.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -16,5 +16,4 @@ #include "Autogen.h" -#include // for NULL #include // for count_if #include // for strict_dynamic_cast, assert, assertf @@ -27,8 +26,10 @@ #include "AddVisit.h" // for addVisit #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign +#include "Common/PassVisitor.h" // for PassVisitor #include "Common/ScopedMap.h" // for ScopedMap<>::const_iterator, Scope... #include "Common/utility.h" // for cloneAll, operator+ -#include "GenPoly/DeclMutator.h" // for DeclMutator #include "GenPoly/ScopedSet.h" // for ScopedSet, ScopedSet<>::iterator +#include "InitTweak/GenInit.h" // for fixReturnStatements +#include "ResolvExpr/Resolver.h" // for resolveDecl #include "SymTab/Mangler.h" // for Mangler #include "SynTree/Attribute.h" // For Attribute @@ -53,35 +54,21 @@ }; - class AutogenerateRoutines final : public Visitor { - template< typename Visitor > - friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor ); - template< typename Visitor > - friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor ); - public: - std::list< Declaration * > &get_declsToAdd() { return declsToAdd; } - - typedef Visitor Parent; - using Parent::visit; - + struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef, public WithGuards, public WithShortCircuiting { AutogenerateRoutines(); - virtual void visit( EnumDecl *enumDecl ); - virtual void visit( StructDecl *structDecl ); - virtual void visit( UnionDecl *structDecl ); - virtual void visit( TypeDecl *typeDecl ); - virtual void visit( TraitDecl *ctxDecl ); - virtual void visit( FunctionDecl *functionDecl ); - - virtual void visit( FunctionType *ftype ); - virtual void visit( PointerType *ftype ); - - virtual void visit( CompoundStmt *compoundStmt ); - virtual void visit( SwitchStmt *switchStmt ); + void previsit( EnumDecl * enumDecl ); + void previsit( StructDecl * structDecl ); + void previsit( UnionDecl * structDecl ); + void previsit( TypeDecl * typeDecl ); + void previsit( TraitDecl * traitDecl ); + void previsit( FunctionDecl * functionDecl ); + + void previsit( FunctionType * ftype ); + void previsit( PointerType * ptype ); + + void previsit( CompoundStmt * compoundStmt ); private: - template< typename StmtClass > void visitStatement( StmtClass *stmt ); - - std::list< Declaration * > declsToAdd, declsToAddAfter; - std::set< std::string > structsDone; + GenPoly::ScopedSet< std::string > structsDone; unsigned int functionNesting = 0; // current level of nested functions /// Note: the following maps could be ScopedSets, but it should be easier to work @@ -93,16 +80,10 @@ /// generates routines for tuple types. - /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit - /// or anything we currently have that supports adding new declarations for visitors - class AutogenTupleRoutines : public GenPoly::DeclMutator { - public: - typedef GenPoly::DeclMutator Parent; - using Parent::mutate; - - virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ); - - virtual Type * mutate( TupleType *tupleType ); - - virtual CompoundStmt * mutate( CompoundStmt *compoundStmt ); + struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef, public WithGuards, public WithShortCircuiting { + void previsit( FunctionDecl *functionDecl ); + + void postvisit( TupleType *tupleType ); + + void previsit( CompoundStmt *compoundStmt ); private: @@ -112,14 +93,14 @@ void autogenerateRoutines( std::list< Declaration * > &translationUnit ) { - AutogenerateRoutines generator; - acceptAndAdd( translationUnit, generator ); + PassVisitor generator; + acceptAll( translationUnit, generator ); // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc. // AutogenTupleRoutines tupleGenerator; - // tupleGenerator.mutateDeclarationList( translationUnit ); + // acceptAll( translationUnit, tupleGenerator ); } bool isUnnamedBitfield( ObjectDecl * obj ) { - return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL; + return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr; } @@ -128,5 +109,5 @@ FunctionDecl * decl = functionDecl->clone(); delete decl->get_statements(); - decl->set_statements( NULL ); + decl->set_statements( nullptr ); declsToAdd.push_back( decl ); decl->fixUniqueId(); @@ -339,5 +320,5 @@ assert( ! func->get_functionType()->get_parameters().empty() ); ObjectDecl * dstParam = dynamic_cast( func->get_functionType()->get_parameters().front() ); - ObjectDecl * srcParam = NULL; + ObjectDecl * srcParam = nullptr; if ( func->get_functionType()->get_parameters().size() == 2 ) { srcParam = dynamic_cast( func->get_functionType()->get_parameters().back() ); @@ -346,5 +327,5 @@ assert( dstParam ); - Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL; + Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr; makeStructMemberOp( dstParam, srcselect, field, func, forward ); } // if @@ -385,5 +366,5 @@ } else { // no matching parameter, initialize field with default ctor - makeStructMemberOp( dstParam, NULL, field, func ); + makeStructMemberOp( dstParam, nullptr, field, func ); } } @@ -401,11 +382,10 @@ void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) { // Builtins do not use autogeneration. - if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA || - aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) { + if ( LinkageSpec::isBuiltin( aggregateDecl->get_linkage() ) ) { return; } // Make function polymorphic in same parameters as generic struct, if applicable - const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions + const std::list< TypeDecl * > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions // generate each of the functions based on the supplied FuncData objects @@ -572,11 +552,12 @@ // the order here determines the order that these functions are generated. // assignment should come last since it uses copy constructor in return. - data.push_back( FuncData( "?{}", genDefaultType, constructable ) ); - data.push_back( FuncData( "?{}", genCopyType, copyable ) ); - data.push_back( FuncData( "^?{}", genDefaultType, destructable ) ); - data.push_back( FuncData( "?=?", genAssignType, assignable ) ); - } - - void AutogenerateRoutines::visit( EnumDecl *enumDecl ) { + data.emplace_back( "?{}", genDefaultType, constructable ); + data.emplace_back( "?{}", genCopyType, copyable ); + data.emplace_back( "^?{}", genDefaultType, destructable ); + data.emplace_back( "?=?", genAssignType, assignable ); + } + + void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) { + visit_children = false; if ( ! enumDecl->get_members().empty() ) { EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() ); @@ -586,19 +567,21 @@ } - void AutogenerateRoutines::visit( StructDecl *structDecl ) { - if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) { - StructInstType structInst( Type::Qualifiers(), structDecl->get_name() ); - for ( TypeDecl * typeDecl : structDecl->get_parameters() ) { + void AutogenerateRoutines::previsit( StructDecl * structDecl ) { + visit_children = false; + if ( structDecl->has_body() && structsDone.find( structDecl->name ) == structsDone.end() ) { + StructInstType structInst( Type::Qualifiers(), structDecl->name ); + for ( TypeDecl * typeDecl : structDecl->parameters ) { // need to visit assertions so that they are added to the appropriate maps - acceptAll( typeDecl->get_assertions(), *this ); - structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) ); + acceptAll( typeDecl->assertions, *visitor ); + structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) ); } structInst.set_baseStruct( structDecl ); makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data ); - structsDone.insert( structDecl->get_name() ); + structsDone.insert( structDecl->name ); } // if } - void AutogenerateRoutines::visit( UnionDecl *unionDecl ) { + void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) { + visit_children = false; if ( ! unionDecl->get_members().empty() ) { UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() ); @@ -619,5 +602,6 @@ // generate ctor/dtors/assign for typedecls, e.g., otype T = int *; - void AutogenerateRoutines::visit( TypeDecl *typeDecl ) { + void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) { + visit_children = false; if ( ! typeDecl->base ) return; @@ -664,31 +648,21 @@ } - void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) { - for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) { - statements.insert( i, new DeclStmt( noLabels, *decl ) ); - } // for - declsToAdd.clear(); - } - - void AutogenerateRoutines::visit( FunctionType *) { + void AutogenerateRoutines::previsit( FunctionType *) { // ensure that we don't add assignment ops for types defined as part of the function - } - - void AutogenerateRoutines::visit( PointerType *) { + visit_children = false; + } + + void AutogenerateRoutines::previsit( PointerType *) { // ensure that we don't add assignment ops for types defined as part of the pointer - } - - void AutogenerateRoutines::visit( TraitDecl *) { + visit_children = false; + } + + void AutogenerateRoutines::previsit( TraitDecl * ) { // ensure that we don't add assignment ops for types defined as part of the trait - } - - template< typename StmtClass > - inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) { - std::set< std::string > oldStructs = structsDone; - addVisit( stmt, *this ); - structsDone = oldStructs; - } - - void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) { + visit_children = false; + } + + void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) { + visit_children = false; // record the existence of this function as appropriate insert( functionDecl, constructable, InitTweak::isDefaultConstructor ); @@ -697,24 +671,16 @@ insert( functionDecl, destructable, InitTweak::isDestructor ); - maybeAccept( functionDecl->get_functionType(), *this ); + maybeAccept( functionDecl->type, *visitor ); functionNesting += 1; - maybeAccept( functionDecl->get_statements(), *this ); + maybeAccept( functionDecl->statements, *visitor ); functionNesting -= 1; } - void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) { - constructable.beginScope(); - assignable.beginScope(); - copyable.beginScope(); - destructable.beginScope(); - visitStatement( compoundStmt ); - constructable.endScope(); - assignable.endScope(); - copyable.endScope(); - destructable.endScope(); - } - - void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) { - visitStatement( switchStmt ); + void AutogenerateRoutines::previsit( CompoundStmt * ) { + GuardScope( constructable ); + GuardScope( assignable ); + GuardScope( copyable ); + GuardScope( destructable ); + GuardScope( structsDone ); } @@ -734,8 +700,7 @@ } - Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) { - tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) ); + void AutogenTupleRoutines::postvisit( TupleType * tupleType ) { std::string mangleName = SymTab::Mangler::mangleType( tupleType ); - if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType; + if ( seenTuples.find( mangleName ) != seenTuples.end() ) return; seenTuples.insert( mangleName ); @@ -785,25 +750,20 @@ makeTupleFunctionBody( dtorDecl ); - addDeclaration( ctorDecl ); - addDeclaration( copyCtorDecl ); - addDeclaration( dtorDecl ); - addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return - - return tupleType; - } - - DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) { - functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) ); + declsToAddBefore.push_back( ctorDecl ); + declsToAddBefore.push_back( copyCtorDecl ); + declsToAddBefore.push_back( dtorDecl ); + declsToAddBefore.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return + } + + void AutogenTupleRoutines::previsit( FunctionDecl *functionDecl ) { + visit_children = false; + maybeAccept( functionDecl->type, *visitor ); functionNesting += 1; - functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) ); + maybeAccept( functionDecl->statements, *visitor ); functionNesting -= 1; - return functionDecl; - } - - CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) { - seenTuples.beginScope(); - compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) ); - seenTuples.endScope(); - return compoundStmt; + } + + void AutogenTupleRoutines::previsit( CompoundStmt * ) { + GuardScope( seenTuples ); } } // SymTab Index: src/SymTab/FixFunction.cc =================================================================== --- src/SymTab/FixFunction.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SymTab/FixFunction.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -27,8 +27,8 @@ DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) { + // can't delete function type because it may contain assertions, so transfer ownership to new object ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() ); functionDecl->get_attributes().clear(); - // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr - functionDecl->set_type( functionDecl->get_type()->clone() ); + functionDecl->type = nullptr; delete functionDecl; return pointer; Index: src/SymTab/Indexer.cc =================================================================== --- src/SymTab/Indexer.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SymTab/Indexer.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -40,17 +40,4 @@ namespace SymTab { - struct NewScope { - NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); } - ~NewScope() { indexer.leaveScope(); } - SymTab::Indexer & indexer; - }; - - template< typename TreeType, typename VisitorType > - inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) { - visitor.enterScope(); - maybeAccept( tree, visitor ); - visitor.leaveScope(); - } - typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable; typedef std::unordered_map< std::string, MangleTable > IdTable; @@ -198,9 +185,9 @@ } - Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {} - - Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {} - - Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) { + Indexer::Indexer() : tables( 0 ), scope( 0 ) {} + + Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {} + + Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) { that.tables = 0; } Index: src/SymTab/Indexer.h =================================================================== --- src/SymTab/Indexer.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SymTab/Indexer.h (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -26,5 +26,5 @@ class Indexer { public: - explicit Indexer( bool useDebug = false ); + explicit Indexer(); Indexer( const Indexer &that ); @@ -76,4 +76,5 @@ void addTrait( TraitDecl *decl ); + bool doDebug = false; ///< Display debugging trace? private: struct Impl; @@ -81,5 +82,4 @@ Impl *tables; ///< Copy-on-write instance of table data structure unsigned long scope; ///< Scope index of this pointer - bool doDebug; ///< Display debugging trace? /// Takes a new ref to a table (returns null if null) Index: src/SymTab/Mangler.cc =================================================================== --- src/SymTab/Mangler.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SymTab/Mangler.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -31,5 +31,5 @@ namespace SymTab { - std::string Mangler::mangleType( Type *ty ) { + std::string Mangler::mangleType( Type * ty ) { Mangler mangler( false, true ); maybeAccept( ty, mangler ); @@ -48,5 +48,5 @@ } - void Mangler::mangleDecl( DeclarationWithType *declaration ) { + void Mangler::mangleDecl( DeclarationWithType * declaration ) { bool wasTopLevel = isTopLevel; if ( isTopLevel ) { @@ -79,18 +79,18 @@ } - void Mangler::visit( ObjectDecl *declaration ) { + void Mangler::visit( ObjectDecl * declaration ) { mangleDecl( declaration ); } - void Mangler::visit( FunctionDecl *declaration ) { + void Mangler::visit( FunctionDecl * declaration ) { mangleDecl( declaration ); } - void Mangler::visit( VoidType *voidType ) { + void Mangler::visit( VoidType * voidType ) { printQualifiers( voidType ); mangleName << "v"; } - void Mangler::visit( BasicType *basicType ) { + void Mangler::visit( BasicType * basicType ) { static const char *btLetter[] = { "b", // Bool @@ -123,5 +123,5 @@ } - void Mangler::visit( PointerType *pointerType ) { + void Mangler::visit( PointerType * pointerType ) { printQualifiers( pointerType ); mangleName << "P"; @@ -129,5 +129,5 @@ } - void Mangler::visit( ArrayType *arrayType ) { + void Mangler::visit( ArrayType * arrayType ) { // TODO: encode dimension printQualifiers( arrayType ); @@ -136,5 +136,5 @@ } - void Mangler::visit( ReferenceType *refType ) { + void Mangler::visit( ReferenceType * refType ) { printQualifiers( refType ); mangleName << "R"; @@ -151,5 +151,5 @@ } - void Mangler::visit( FunctionType *functionType ) { + void Mangler::visit( FunctionType * functionType ) { printQualifiers( functionType ); mangleName << "F"; @@ -162,5 +162,5 @@ } - void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) { + void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) { printQualifiers( refType ); @@ -168,5 +168,5 @@ } - void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) { + void Mangler::mangleGenericRef( ReferenceToType * refType, std::string prefix ) { printQualifiers( refType ); @@ -191,19 +191,19 @@ } - void Mangler::visit( StructInstType *aggregateUseType ) { + void Mangler::visit( StructInstType * aggregateUseType ) { if ( typeMode ) mangleGenericRef( aggregateUseType, "s" ); else mangleRef( aggregateUseType, "s" ); } - void Mangler::visit( UnionInstType *aggregateUseType ) { + void Mangler::visit( UnionInstType * aggregateUseType ) { if ( typeMode ) mangleGenericRef( aggregateUseType, "u" ); else mangleRef( aggregateUseType, "u" ); } - void Mangler::visit( EnumInstType *aggregateUseType ) { + void Mangler::visit( EnumInstType * aggregateUseType ) { mangleRef( aggregateUseType, "e" ); } - void Mangler::visit( TypeInstType *typeInst ) { + void Mangler::visit( TypeInstType * typeInst ) { VarMapType::iterator varNum = varNums.find( typeInst->get_name() ); if ( varNum == varNums.end() ) { @@ -233,27 +233,27 @@ } - void Mangler::visit( TupleType *tupleType ) { + void Mangler::visit( TupleType * tupleType ) { printQualifiers( tupleType ); mangleName << "T"; - acceptAll( tupleType->get_types(), *this ); + acceptAll( tupleType->types, *this ); mangleName << "_"; } - void Mangler::visit( VarArgsType *varArgsType ) { + void Mangler::visit( VarArgsType * varArgsType ) { printQualifiers( varArgsType ); mangleName << "VARGS"; } - void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) { + void Mangler::visit( ZeroType * ) { mangleName << "Z"; } - void Mangler::visit( __attribute__((unused)) OneType *oneType ) { + void Mangler::visit( OneType * ) { mangleName << "O"; } - void Mangler::visit( TypeDecl *decl ) { + void Mangler::visit( TypeDecl * decl ) { static const char *typePrefix[] = { "BT", "BD", "BF" }; - mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name(); + mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name; } @@ -264,5 +264,5 @@ } - void Mangler::printQualifiers( Type *type ) { + void Mangler::printQualifiers( Type * type ) { // skip if not including qualifiers if ( typeMode ) return; @@ -272,5 +272,5 @@ int tcount = 0, dcount = 0, fcount = 0, vcount = 0; mangleName << "A"; - for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) { + for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) { switch ( (*i)->get_kind() ) { case TypeDecl::Any: @@ -289,6 +289,6 @@ assert( false ); } // switch - varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() ); - for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) { + varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() ); + for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) { Mangler sub_mangler( mangleOverridable, typeMode ); sub_mangler.nextVarNum = nextVarNum; @@ -309,4 +309,7 @@ mangleName << "V"; } // if + if ( type->get_mutex() ) { + mangleName << "M"; + } // if // Removed due to restrict not affecting function compatibility in GCC // if ( type->get_isRestrict() ) { @@ -314,6 +317,7 @@ // } // if if ( type->get_lvalue() ) { + // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues mangleName << "L"; - } // if + } if ( type->get_atomic() ) { mangleName << "A"; Index: src/SymTab/Validate.cc =================================================================== --- src/SymTab/Validate.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SymTab/Validate.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -56,4 +56,5 @@ #include "FixFunction.h" // for FixFunction #include "Indexer.h" // for Indexer +#include "InitTweak/GenInit.h" // for fixReturnStatements #include "InitTweak/InitTweak.h" // for isCtorDtorAssign #include "Parser/LinkageSpec.h" // for C @@ -150,6 +151,6 @@ /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID. struct ForallPointerDecay final { - void previsit( ObjectDecl *object ); - void previsit( FunctionDecl *func ); + void previsit( ObjectDecl * object ); + void previsit( FunctionDecl * func ); }; @@ -579,6 +580,6 @@ /// Fix up assertions - flattens assertion lists, removing all trait instances - void forallFixer( Type * func ) { - for ( TypeDecl * type : func->get_forall() ) { + void forallFixer( std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) { + for ( TypeDecl * type : forall ) { std::list< DeclarationWithType * > asserts; asserts.splice( asserts.end(), type->assertions ); @@ -599,5 +600,5 @@ assertion = assertion->acceptMutator( fixer ); if ( fixer.get_isVoid() ) { - throw SemanticError( "invalid type void in assertion of function ", func ); + throw SemanticError( "invalid type void in assertion of function ", node ); } // if } // for @@ -607,7 +608,7 @@ void ForallPointerDecay::previsit( ObjectDecl *object ) { - forallFixer( object->get_type() ); - if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) { - forallFixer( pointer->get_base() ); + forallFixer( object->type->forall, object ); + if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) { + forallFixer( pointer->base->forall, object ); } // if object->fixUniqueId(); @@ -615,5 +616,5 @@ void ForallPointerDecay::previsit( FunctionDecl *func ) { - forallFixer( func->get_type() ); + forallFixer( func->type->forall, func ); func->fixUniqueId(); } Index: c/SynTree/AddStmtVisitor.cc =================================================================== --- src/SynTree/AddStmtVisitor.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ (revision ) @@ -1,93 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// AddStmtVisitor.cc -- -// -// Author : Rob Schluntz -// Created On : Wed Jun 22 12:11:17 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Thu Aug 4 11:23:47 2016 -// Update Count : 16 -// - -#include "AddStmtVisitor.h" - -#include "Common/SemanticError.h" // for SemanticError -#include "Declaration.h" // for Declaration -#include "Expression.h" // for Expression -#include "Statement.h" // for CompoundStmt, ForStmt, IfStmt, Sta... -#include "SynTree/Label.h" // for Label, noLabels - -void AddStmtVisitor::visitStatementList( std::list< Statement* > &statements ) { - for ( std::list< Statement* >::iterator i = statements.begin(); i != statements.end(); ++i ) { - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( i, stmtsToAddAfter ); - } // if - (*i)->accept( *this ); - if ( ! stmtsToAdd.empty() ) { - statements.splice( i, stmtsToAdd ); - } // if - } // for - if ( ! stmtsToAddAfter.empty() ) { - statements.splice( statements.end(), stmtsToAddAfter ); - } // if -} - -Statement * AddStmtVisitor::visitStatement( Statement *stmt ) { - maybeAccept( stmt, *this ); - if ( ! stmtsToAdd.empty() || ! stmtsToAddAfter.empty() ) { - CompoundStmt *compound = new CompoundStmt( noLabels ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAdd ); - compound->get_kids().push_back( stmt ); - compound->get_kids().splice( compound->get_kids().end(), stmtsToAddAfter ); - return compound; - } else { - return stmt; - } -} - -void AddStmtVisitor::visit(CompoundStmt *compoundStmt) { - visitStatementList( compoundStmt->get_kids() ); -} - -void AddStmtVisitor::visit(IfStmt *ifStmt) { - ifStmt->set_thenPart( visitStatement( ifStmt->get_thenPart() ) ); - ifStmt->set_elsePart( visitStatement( ifStmt->get_elsePart() ) ); - maybeAccept( ifStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(WhileStmt *whileStmt) { - whileStmt->set_body( visitStatement( whileStmt->get_body() ) ); - maybeAccept( whileStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(ForStmt *forStmt) { - forStmt->set_body( visitStatement( forStmt->get_body() ) ); - acceptAll( forStmt->get_initialization(), *this ); - maybeAccept( forStmt->get_condition(), *this ); - maybeAccept( forStmt->get_increment(), *this ); -} - -void AddStmtVisitor::visit(SwitchStmt *switchStmt) { - visitStatementList( switchStmt->get_statements() ); - maybeAccept( switchStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(CaseStmt *caseStmt) { - visitStatementList( caseStmt->get_statements() ); - maybeAccept( caseStmt->get_condition(), *this ); -} - -void AddStmtVisitor::visit(CatchStmt *catchStmt) { - catchStmt->set_body( visitStatement( catchStmt->get_body() ) ); - maybeAccept( catchStmt->get_decl(), *this ); -} - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: c/SynTree/AddStmtVisitor.h =================================================================== --- src/SynTree/AddStmtVisitor.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ (revision ) @@ -1,47 +1,0 @@ -// -// Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo -// -// The contents of this file are covered under the licence agreement in the -// file "LICENCE" distributed with Cforall. -// -// AddStmtVisitor.h -- -// -// Author : Rob Schluntz -// Created On : Wed Jun 22 12:05:48 2016 -// Last Modified By : Peter A. Buhr -// Last Modified On : Sat Jul 22 09:51:08 2017 -// Update Count : 9 -// - -#pragma once - -#include // for list - -#include "SynTree/SynTree.h" // for Visitor Nodes -#include "SynTree/Visitor.h" // for Visitor - -class AddStmtVisitor : public Visitor { - public: - typedef Visitor Parent; - - using Parent::visit; - virtual void visit(CompoundStmt *compoundStmt); - virtual void visit(IfStmt *ifStmt); - virtual void visit(WhileStmt *whileStmt); - virtual void visit(ForStmt *forStmt); - virtual void visit(SwitchStmt *switchStmt); - virtual void visit(CaseStmt *caseStmt); - virtual void visit(CatchStmt *catchStmt); - - protected: - void visitStatementList( std::list< Statement * > & ); - Statement * visitStatement( Statement * ); - std::list< Statement* > stmtsToAdd; - std::list< Statement* > stmtsToAddAfter; -}; - -// Local Variables: // -// tab-width: 4 // -// mode: c++ // -// compile-command: "make install" // -// End: // Index: src/SynTree/BaseSyntaxNode.h =================================================================== --- src/SynTree/BaseSyntaxNode.h (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SynTree/BaseSyntaxNode.h (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -26,6 +26,8 @@ virtual void accept( Visitor & v ) = 0; - virtual void print( std::ostream & os, int indent = 0 ) const = 0; + virtual void print( std::ostream & os, int indent = 0 ) const = 0; }; + +std::ostream & operator<<( std::ostream & out, const BaseSyntaxNode * node ); // Local Variables: // Index: src/SynTree/CompoundStmt.cc =================================================================== --- src/SynTree/CompoundStmt.cc (revision 201aeb9b7c42eb7c7aa8bc065247bffda4932b33) +++ src/SynTree/CompoundStmt.cc (revision d67cdb749954789d84d7a8bbabc0ec601347a7bb) @@ -29,4 +29,7 @@ CompoundStmt::CompoundStmt( std::list