Changes in / [97c215f:f5a51db]


Ignore:
Files:
8 added
75 edited

Legend:

Unmodified
Added
Removed

  • benchmark/io/http/Makefile.am

    r97c215f rf5a51db  
    2121include $(top_srcdir)/tools/build/cfa.make
    2222
    23 AM_CFLAGS = -O2 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
     23AM_CFLAGS = -O3 -Wall -Wextra -I$(srcdir) -lrt -pthread # -Werror
    2424AM_CFAFLAGS = -quiet -nodebug
    2525AM_LDFLAGS = -quiet -nodebug

  • benchmark/io/http/main.cfa

    r97c215f rf5a51db  
    1 #define __USE_GNU
     1#define _GNU_SOURCE
    22
    33#include <errno.h>
    … …  
    66#include <unistd.h>
    77extern "C" {
     8        #include <sched.h>
    89        #include <signal.h>
    910        #include <sys/socket.h>
    … …  
    6768        (this.self){ "Server Cluster", options.clopts.params };
    6869
     70        cpu_set_t fullset;
     71        CPU_ZERO(&fullset);
     72        int ret = sched_getaffinity(getpid(), sizeof(fullset), &fullset);
     73        if( ret != 0 ) abort | "sched_getaffinity failed with" | errno | strerror( errno );
     74        int cnt = CPU_COUNT(&fullset);
     75
    6976        this.procs = alloc(options.clopts.nprocs);
    7077        for(i; options.clopts.nprocs) {
    7178                (this.procs[i]){ "Benchmark Processor", this.self };
     79
     80                int c = 0;
     81                int n = 1 + (i % cnt);
     82                for(int j = 0; j < CPU_SETSIZE; j++) {
     83                        if(CPU_ISSET(j, &fullset)) n--;
     84                        if(n == 0) {
     85                                c = j;
     86                                break;
     87                        }
     88                }
     89                cpu_set_t localset;
     90                CPU_ZERO(&localset);
     91                CPU_SET(c, &localset);
     92                ret = pthread_setaffinity_np(this.procs[i].kernel_thread, sizeof(localset), &localset);
     93                if( ret != 0 ) abort | "sched_getaffinity failed with" | ret | strerror( ret );
    7294
    7395                #if !defined(__CFA_NO_STATISTICS__)
    … …  
    146168        int waited = 0;
    147169        for() {
    148                 ret = bind( server_fd, (struct sockaddr *)&address, sizeof(address) );
     170                int sockfd = server_fd;
     171                __CONST_SOCKADDR_ARG addr;
     172                addr.__sockaddr__ = (struct sockaddr *)&address;
     173                socklen_t addrlen = sizeof(address);
     174                ret = bind( sockfd, addr, addrlen );
    149175                if(ret < 0) {
    150176                        if(errno == EADDRINUSE) {

  • doc/theses/thierry_delisle_PhD/thesis/Makefile

    r97c215f rf5a51db  
    4848## Define the documents that need to be made.
    4949all: thesis.pdf
    50 thesis.pdf: ${TEXTS} ${FIGURES} ${PICTURES} thesis.tex glossary.tex local.bib
     50thesis.pdf: ${TEXTS} ${FIGURES} ${PICTURES} thesis.tex glossary.tex local.bib ../../../LaTeXmacros/common.tex ../../../LaTeXmacros/common.sty
    5151
    5252DOCUMENT = thesis.pdf

  • doc/theses/thierry_delisle_PhD/thesis/fig/base.fig

    r97c215f rf5a51db  
    12121 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6900 4200 20 20 6900 4200 6920 4200
    13131 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6975 4200 20 20 6975 4200 6995 4200
     14-6
     156 6375 5100 6675 5250
     161 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6450 5175 20 20 6450 5175 6470 5175
     171 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6525 5175 20 20 6525 5175 6545 5175
     181 3 0 1 0 0 50 -1 20 0.000 1 0.0000 6600 5175 20 20 6600 5175 6620 5175
    1419-6
    15201 3 0 1 0 7 50 -1 -1 0.000 1 0.0000 3900 2400 300 300 3900 2400 4200 2400
    … …  
    75802 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
    7681         2400 2475 3000 2475
     822 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7
     83         3300 5210 3150 4950 2850 4950 2700 5210 2850 5470 3150 5470
     84         3300 5210
     852 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7
     86         4500 5210 4350 4950 4050 4950 3900 5210 4050 5470 4350 5470
     87         4500 5210
     882 3 0 1 0 7 50 -1 -1 0.000 0 0 0 0 0 7
     89         5700 5210 5550 4950 5250 4950 5100 5210 5250 5470 5550 5470
     90         5700 5210
    77914 2 -1 50 -1 0 12 0.0000 2 135 630 2100 3075 Threads\001
    78924 2 -1 50 -1 0 12 0.0000 2 165 450 2100 2850 Ready\001
    … …  
    82964 1 -1 50 -1 0 11 0.0000 2 135 180 2700 3550 TS\001
    83974 1 -1 50 -1 0 11 0.0000 2 135 180 2700 2650 TS\001
     984 2 -1 50 -1 0 12 0.0000 2 135 900 2100 5175 Processors\001

  • doc/theses/thierry_delisle_PhD/thesis/glossary.tex

    r97c215f rf5a51db  
    4040
    4141\textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.}
     42}
     43
     44\longnewglossaryentry{rmr}
     45{name={remote memory reference}}
     46{
     47
    4248}
    4349

  • doc/theses/thierry_delisle_PhD/thesis/text/core.tex

    r97c215f rf5a51db  
    4949
    5050\section{Design}
    51 In general, a na\"{i}ve \glsxtrshort{fifo} ready-queue does not scale with increased parallelism from \glspl{hthrd}, resulting in decreased performance. The problem is adding/removing \glspl{thrd} is a single point of contention. As shown in the evaluation sections, most production schedulers do scale when adding \glspl{hthrd}. The common solution to the single point of contention is to shard the ready-queue so each \gls{hthrd} can access the ready-queue without contention, increasing performance.
     51In general, a na\"{i}ve \glsxtrshort{fifo} ready-queue does not scale with increased parallelism from \glspl{hthrd}, resulting in decreased performance. The problem is adding/removing \glspl{thrd} is a single point of contention. As shown in the evaluation sections, most production schedulers do scale when adding \glspl{hthrd}. The solution to this problem is to shard the ready-queue : create multiple sub-ready-queues that multiple \glspl{hthrd} can access and modify without interfering.
    5252
    53 \subsection{Sharding} \label{sec:sharding}
    54 An interesting approach to sharding a queue is presented in \cit{Trevors paper}. This algorithm presents a queue with a relaxed \glsxtrshort{fifo} guarantee using an array of strictly \glsxtrshort{fifo} sublists as shown in Figure~\ref{fig:base}. Each \emph{cell} of the array has a timestamp for the last operation and a pointer to a linked-list with a lock. Each node in the list is marked with a timestamp indicating when it is added to the list. A push operation is done by picking a random cell, acquiring the list lock, and pushing to the list. If the cell is locked, the operation is simply retried on another random cell until a lock is acquired. A pop operation is done in a similar fashion except two random cells are picked. If both cells are unlocked with non-empty lists, the operation pops the node with the oldest timestamp. If one of the cells is unlocked and non-empty, the operation pops from that cell. If both cells are either locked or empty, the operation picks two new random cells and tries again.
     53Before going into the design of \CFA's scheduler proper, I want to discuss two sharding solutions which served as the inspiration scheduler in this thesis.
    5554
     55\subsection{Work-Stealing}
     56
     57As I mentioned in \ref{existing:workstealing}, a popular pattern shard the ready-queue is work-stealing. As mentionned, in this pattern each \gls{proc} has its own ready-queue and \glspl{proc} only access each other's ready-queue if they run out of work.
     58The interesting aspect of workstealing happen in easier scheduling cases, \ie enough work for everyone but no more and no load balancing needed. In these cases, work-stealing is close to optimal scheduling: it can achieve perfect locality and have no contention.
     59On the other hand, work-stealing schedulers only attempt to do load-balancing when a \gls{proc} runs out of work.
     60This means that the scheduler may never balance unfairness that does not result in a \gls{proc} running out of work.
     61Chapter~\ref{microbench} shows that in pathological cases this problem can lead to indefinite starvation.
     62
     63
     64Based on these observation, I conclude that \emph{perfect} scheduler should behave very similarly to work-stealing in the easy cases, but should have more proactive load-balancing if the need arises.
     65
     66\subsection{Relaxed-Fifo}
     67An entirely different scheme is to create a ``relaxed-FIFO'' queue as in \todo{cite Trevor's paper}. This approach forgos any ownership between \gls{proc} and ready-queue, and simply creates a pool of ready-queues from which the \glspl{proc} can pick from.
     68\Glspl{proc} choose ready-queus at random, but timestamps are added to all elements of the queue and dequeues are done by picking two queues and dequeing the oldest element.
     69The result is a queue that has both decent scalability and sufficient fairness.
     70The lack of ownership means that as long as one \gls{proc} is still able to repeatedly dequeue elements, it is unlikely that any element will stay on the queue for much longer than any other element.
     71This contrasts with work-stealing, where \emph{any} \gls{proc} busy for an extended period of time results in all the elements on its local queue to have to wait. Unless another \gls{proc} runs out of work.
     72
     73An important aspects of this scheme's fairness approach is that the timestamps make it possible to evaluate how long elements have been on the queue.
     74However, another major aspect is that \glspl{proc} will eagerly search for these older elements instead of focusing on specific queues.
     75
     76While the fairness, of this scheme is good, it does suffer in terms of performance.
     77It requires very wide sharding, \eg at least 4 queues per \gls{hthrd}, and the randomness means locality can suffer significantly and finding non-empty queues can be difficult.
     78
     79\section{\CFA}
     80The \CFA is effectively attempting to merge these two approaches, keeping the best of both.
     81It is based on the
    5682\begin{figure}
    5783        \centering
    5884        \input{base.pstex_t}
    59         \caption[Relaxed FIFO list]{Relaxed FIFO list \smallskip\newline List at the base of the scheduler: an array of strictly FIFO lists. The timestamp is in all nodes and cell arrays.}
     85        \caption[Base \CFA design]{Base \CFA design \smallskip\newline A list of sub-ready queues offers the sharding, two per \glspl{proc}. However, \glspl{proc} can access any of the sub-queues.}
    6086        \label{fig:base}
    6187\end{figure}
    6288
    63 \subsection{Finding threads}
    64 Once threads have been distributed onto multiple queues, identifying empty queues becomes a problem. Indeed, if the number of \glspl{thrd} does not far exceed the number of queues, it is probable that several of the cell queues are empty. Figure~\ref{fig:empty} shows an example with 2 \glspl{thrd} running on 8 queues, where the chances of getting an empty queue is 75\% per pick, meaning two random picks yield a \gls{thrd} only half the time. This scenario leads to performance problems since picks that do not yield a \gls{thrd} are not useful and do not necessarily help make more informed guesses.
    6589
    66 \begin{figure}
    67         \centering
    68         \input{empty.pstex_t}
    69         \caption[``More empty'' Relaxed FIFO list]{``More empty'' Relaxed FIFO list \smallskip\newline Emptier state of the queue: the array contains many empty cells, that is strictly FIFO lists containing no elements.}
    70         \label{fig:empty}
    71 \end{figure}
    7290
    73 There are several solutions to this problem, but they ultimately all have to encode if a cell has an empty list. My results show the density and locality of this encoding is generally the dominating factor in these scheme. Classic solutions to this problem use one of three techniques to encode the information:
     91% The common solution to the single point of contention is to shard the ready-queue so each \gls{hthrd} can access the ready-queue without contention, increasing performance.
    7492
    75 \paragraph{Dense Information} Figure~\ref{fig:emptybit} shows a dense bitmask to identify the cell queues currently in use. This approach means processors can often find \glspl{thrd} in constant time, regardless of how many underlying queues are empty. Furthermore, modern x86 CPUs have extended bit manipulation instructions (BMI2) that allow searching the bitmask with very little overhead compared to the randomized selection approach for a filled ready queue, offering good performance even in cases with many empty inner queues. However, this technique has its limits: with a single word\footnote{Word refers here to however many bits can be written atomically.} bitmask, the total amount of ready-queue sharding is limited to the number of bits in the word. With a multi-word bitmask, this maximum limit can be increased arbitrarily, but the look-up time increases. Finally, a dense bitmap, either single or multi-word, causes additional contention problems that reduces performance because of cache misses after updates. This central update bottleneck also means the information in the bitmask is more often stale before a processor can use it to find an item, \ie mask read says there are available \glspl{thrd} but none on queue when the subsequent atomic check is done.
     93% \subsection{Sharding} \label{sec:sharding}
     94% An interesting approach to sharding a queue is presented in \cit{Trevors paper}. This algorithm presents a queue with a relaxed \glsxtrshort{fifo} guarantee using an array of strictly \glsxtrshort{fifo} sublists as shown in Figure~\ref{fig:base}. Each \emph{cell} of the array has a timestamp for the last operation and a pointer to a linked-list with a lock. Each node in the list is marked with a timestamp indicating when it is added to the list. A push operation is done by picking a random cell, acquiring the list lock, and pushing to the list. If the cell is locked, the operation is simply retried on another random cell until a lock is acquired. A pop operation is done in a similar fashion except two random cells are picked. If both cells are unlocked with non-empty lists, the operation pops the node with the oldest timestamp. If one of the cells is unlocked and non-empty, the operation pops from that cell. If both cells are either locked or empty, the operation picks two new random cells and tries again.
    7695
    77 \begin{figure}
    78         \centering
    79         \vspace*{-5pt}
    80         {\resizebox{0.75\textwidth}{!}{\input{emptybit.pstex_t}}}
    81         \vspace*{-5pt}
    82         \caption[Underloaded queue with bitmask]{Underloaded queue with bitmask indicating array cells with items.}
    83         \label{fig:emptybit}
     96% \begin{figure}
     97%       \centering
     98%       \input{base.pstex_t}
     99%       \caption[Relaxed FIFO list]{Relaxed FIFO list \smallskip\newline List at the base of the scheduler: an array of strictly FIFO lists. The timestamp is in all nodes and cell arrays.}
     100%       \label{fig:base}
     101% \end{figure}
    84102
    85         \vspace*{10pt}
    86         {\resizebox{0.75\textwidth}{!}{\input{emptytree.pstex_t}}}
    87         \vspace*{-5pt}
    88         \caption[Underloaded queue with binary search-tree]{Underloaded queue with binary search-tree indicating array cells with items.}
    89         \label{fig:emptytree}
     103% \subsection{Finding threads}
     104% Once threads have been distributed onto multiple queues, identifying empty queues becomes a problem. Indeed, if the number of \glspl{thrd} does not far exceed the number of queues, it is probable that several of the cell queues are empty. Figure~\ref{fig:empty} shows an example with 2 \glspl{thrd} running on 8 queues, where the chances of getting an empty queue is 75\% per pick, meaning two random picks yield a \gls{thrd} only half the time. This scenario leads to performance problems since picks that do not yield a \gls{thrd} are not useful and do not necessarily help make more informed guesses.
    90105
    91         \vspace*{10pt}
    92         {\resizebox{0.95\textwidth}{!}{\input{emptytls.pstex_t}}}
    93         \vspace*{-5pt}
    94         \caption[Underloaded queue with per processor bitmask]{Underloaded queue with per processor bitmask indicating array cells with items.}
    95         \label{fig:emptytls}
    96 \end{figure}
     106% \begin{figure}
     107%       \centering
     108%       \input{empty.pstex_t}
     109%       \caption[``More empty'' Relaxed FIFO list]{``More empty'' Relaxed FIFO list \smallskip\newline Emptier state of the queue: the array contains many empty cells, that is strictly FIFO lists containing no elements.}
     110%       \label{fig:empty}
     111% \end{figure}
    97112
    98 \paragraph{Sparse Information} Figure~\ref{fig:emptytree} shows an approach using a hierarchical tree data-structure to reduce contention and has been shown to work in similar cases~\cite{ellen2007snzi}. However, this approach may lead to poorer performance due to the inherent pointer chasing cost while still allowing significant contention on the nodes of the tree if the tree is shallow.
     113% There are several solutions to this problem, but they ultimately all have to encode if a cell has an empty list. My results show the density and locality of this encoding is generally the dominating factor in these scheme. Classic solutions to this problem use one of three techniques to encode the information:
    99114
    100 \paragraph{Local Information} Figure~\ref{fig:emptytls} shows an approach using dense information, similar to the bitmap, but each \gls{hthrd} keeps its own independent copy. While this approach can offer good scalability \emph{and} low latency, the liveliness and discovery of the information can become a problem. This case is made worst in systems with few processors where even blind random picks can find \glspl{thrd} in a few tries.
     115% \paragraph{Dense Information} Figure~\ref{fig:emptybit} shows a dense bitmask to identify the cell queues currently in use. This approach means processors can often find \glspl{thrd} in constant time, regardless of how many underlying queues are empty. Furthermore, modern x86 CPUs have extended bit manipulation instructions (BMI2) that allow searching the bitmask with very little overhead compared to the randomized selection approach for a filled ready queue, offering good performance even in cases with many empty inner queues. However, this technique has its limits: with a single word\footnote{Word refers here to however many bits can be written atomically.} bitmask, the total amount of ready-queue sharding is limited to the number of bits in the word. With a multi-word bitmask, this maximum limit can be increased arbitrarily, but the look-up time increases. Finally, a dense bitmap, either single or multi-word, causes additional contention problems that reduces performance because of cache misses after updates. This central update bottleneck also means the information in the bitmask is more often stale before a processor can use it to find an item, \ie mask read says there are available \glspl{thrd} but none on queue when the subsequent atomic check is done.
    101116
    102 I built a prototype of these approaches and none of these techniques offer satisfying performance when few threads are present. All of these approach hit the same 2 problems. First, randomly picking sub-queues is very fast. That speed means any improvement to the hit rate can easily be countered by a slow-down in look-up speed, whether or not there are empty lists. Second, the array is already sharded to avoid contention bottlenecks, so any denser data structure tends to become a bottleneck. In all cases, these factors meant the best cases scenario, \ie many threads, would get worst throughput, and the worst-case scenario, few threads, would get a better hit rate, but an equivalent poor throughput. As a result I tried an entirely different approach.
     117% \begin{figure}
     118%       \centering
     119%       \vspace*{-5pt}
     120%       {\resizebox{0.75\textwidth}{!}{\input{emptybit.pstex_t}}}
     121%       \vspace*{-5pt}
     122%       \caption[Underloaded queue with bitmask]{Underloaded queue with bitmask indicating array cells with items.}
     123%       \label{fig:emptybit}
    103124
    104 \subsection{Dynamic Entropy}\cit{https://xkcd.com/2318/}
    105 In the worst-case scenario there are only few \glspl{thrd} ready to run, or more precisely given $P$ \glspl{proc}\footnote{For simplicity, this assumes there is a one-to-one match between \glspl{proc} and \glspl{hthrd}.}, $T$ \glspl{thrd} and $\epsilon$ a very small number, than the worst case scenario can be represented by $T = P + \epsilon$, with $\epsilon \ll P$. It is important to note in this case that fairness is effectively irrelevant. Indeed, this case is close to \emph{actually matching} the model of the ``Ideal multi-tasking CPU'' on page \pageref{q:LinuxCFS}. In this context, it is possible to use a purely internal-locality based approach and still meet the fairness requirements. This approach simply has each \gls{proc} running a single \gls{thrd} repeatedly. Or from the shared ready-queue viewpoint, each \gls{proc} pushes to a given sub-queue and then pops from the \emph{same} subqueue. The challenge is for the the scheduler to achieve good performance in both the $T = P + \epsilon$ case and the $T \gg P$ case, without affecting the fairness guarantees in the later.
     125%       \vspace*{10pt}
     126%       {\resizebox{0.75\textwidth}{!}{\input{emptytree.pstex_t}}}
     127%       \vspace*{-5pt}
     128%       \caption[Underloaded queue with binary search-tree]{Underloaded queue with binary search-tree indicating array cells with items.}
     129%       \label{fig:emptytree}
    106130
    107 To handle this case, I use a \glsxtrshort{prng}\todo{Fix missing long form} in a novel way. There exist \glsxtrshort{prng}s that are fast, compact and can be run forward \emph{and} backwards.  Linear congruential generators~\cite{wiki:lcg} are an example of \glsxtrshort{prng}s of such \glsxtrshort{prng}s. The novel approach is to use the ability to run backwards to ``replay'' the \glsxtrshort{prng}. The scheduler uses an exclusive \glsxtrshort{prng} instance per \gls{proc}, the random-number seed effectively starts an encoding that produces a list of all accessed subqueues, from latest to oldest. Replaying the \glsxtrshort{prng} to identify cells accessed recently and which probably have data still cached.
     131%       \vspace*{10pt}
     132%       {\resizebox{0.95\textwidth}{!}{\input{emptytls.pstex_t}}}
     133%       \vspace*{-5pt}
     134%       \caption[Underloaded queue with per processor bitmask]{Underloaded queue with per processor bitmask indicating array cells with items.}
     135%       \label{fig:emptytls}
     136% \end{figure}
    108137
    109 The algorithm works as follows:
    110 \begin{itemize}
    111         \item Each \gls{proc} has two \glsxtrshort{prng} instances, $F$ and $B$.
    112         \item Push and Pop operations occur as discussed in Section~\ref{sec:sharding} with the following exceptions:
    113         \begin{itemize}
    114                 \item Push operations use $F$ going forward on each try and on success $F$ is copied into $B$.
    115                 \item Pop operations use $B$ going backwards on each try.
    116         \end{itemize}
    117 \end{itemize}
     138% \paragraph{Sparse Information} Figure~\ref{fig:emptytree} shows an approach using a hierarchical tree data-structure to reduce contention and has been shown to work in similar cases~\cite{ellen2007snzi}. However, this approach may lead to poorer performance due to the inherent pointer chasing cost while still allowing significant contention on the nodes of the tree if the tree is shallow.
    118139
    119 The main benefit of this technique is that it basically respects the desired properties of Figure~\ref{fig:fair}. When looking for work, a \gls{proc} first looks at the last cell they pushed to, if any, and then move backwards through its accessed cells. As the \gls{proc} continues looking for work, $F$ moves backwards and $B$ stays in place. As a result, the relation between the two becomes weaker, which means that the probablisitic fairness of the algorithm reverts to normal. Chapter~\ref{proofs} discusses more formally the fairness guarantees of this algorithm.
     140% \paragraph{Local Information} Figure~\ref{fig:emptytls} shows an approach using dense information, similar to the bitmap, but each \gls{hthrd} keeps its own independent copy. While this approach can offer good scalability \emph{and} low latency, the liveliness and discovery of the information can become a problem. This case is made worst in systems with few processors where even blind random picks can find \glspl{thrd} in a few tries.
    120141
    121 \section{Details}
     142% I built a prototype of these approaches and none of these techniques offer satisfying performance when few threads are present. All of these approach hit the same 2 problems. First, randomly picking sub-queues is very fast. That speed means any improvement to the hit rate can easily be countered by a slow-down in look-up speed, whether or not there are empty lists. Second, the array is already sharded to avoid contention bottlenecks, so any denser data structure tends to become a bottleneck. In all cases, these factors meant the best cases scenario, \ie many threads, would get worst throughput, and the worst-case scenario, few threads, would get a better hit rate, but an equivalent poor throughput. As a result I tried an entirely different approach.
     143
     144% \subsection{Dynamic Entropy}\cit{https://xkcd.com/2318/}
     145% In the worst-case scenario there are only few \glspl{thrd} ready to run, or more precisely given $P$ \glspl{proc}\footnote{For simplicity, this assumes there is a one-to-one match between \glspl{proc} and \glspl{hthrd}.}, $T$ \glspl{thrd} and $\epsilon$ a very small number, than the worst case scenario can be represented by $T = P + \epsilon$, with $\epsilon \ll P$. It is important to note in this case that fairness is effectively irrelevant. Indeed, this case is close to \emph{actually matching} the model of the ``Ideal multi-tasking CPU'' on page \pageref{q:LinuxCFS}. In this context, it is possible to use a purely internal-locality based approach and still meet the fairness requirements. This approach simply has each \gls{proc} running a single \gls{thrd} repeatedly. Or from the shared ready-queue viewpoint, each \gls{proc} pushes to a given sub-queue and then pops from the \emph{same} subqueue. The challenge is for the the scheduler to achieve good performance in both the $T = P + \epsilon$ case and the $T \gg P$ case, without affecting the fairness guarantees in the later.
     146
     147% To handle this case, I use a \glsxtrshort{prng}\todo{Fix missing long form} in a novel way. There exist \glsxtrshort{prng}s that are fast, compact and can be run forward \emph{and} backwards.  Linear congruential generators~\cite{wiki:lcg} are an example of \glsxtrshort{prng}s of such \glsxtrshort{prng}s. The novel approach is to use the ability to run backwards to ``replay'' the \glsxtrshort{prng}. The scheduler uses an exclusive \glsxtrshort{prng} instance per \gls{proc}, the random-number seed effectively starts an encoding that produces a list of all accessed subqueues, from latest to oldest. Replaying the \glsxtrshort{prng} to identify cells accessed recently and which probably have data still cached.
     148
     149% The algorithm works as follows:
     150% \begin{itemize}
     151%       \item Each \gls{proc} has two \glsxtrshort{prng} instances, $F$ and $B$.
     152%       \item Push and Pop operations occur as discussed in Section~\ref{sec:sharding} with the following exceptions:
     153%       \begin{itemize}
     154%               \item Push operations use $F$ going forward on each try and on success $F$ is copied into $B$.
     155%               \item Pop operations use $B$ going backwards on each try.
     156%       \end{itemize}
     157% \end{itemize}
     158
     159% The main benefit of this technique is that it basically respects the desired properties of Figure~\ref{fig:fair}. When looking for work, a \gls{proc} first looks at the last cell they pushed to, if any, and then move backwards through its accessed cells. As the \gls{proc} continues looking for work, $F$ moves backwards and $B$ stays in place. As a result, the relation between the two becomes weaker, which means that the probablisitic fairness of the algorithm reverts to normal. Chapter~\ref{proofs} discusses more formally the fairness guarantees of this algorithm.
     160
     161% \section{Details}

  • doc/theses/thierry_delisle_PhD/thesis/text/eval_macro.tex

    r97c215f rf5a51db  
    44
    55In Memory Plain Text
    6 
    7 Networked Plain Text
    86
    97Networked ZIPF

  • doc/theses/thierry_delisle_PhD/thesis/text/eval_micro.tex

    r97c215f rf5a51db  
    22
    33The first step of evaluation is always to test-out small controlled cases, to ensure that the basics are working properly.
    4 This sections presents four different experimental setup, evaluating some of the basic features of \CFA's scheduler.
     4This sections presents five different experimental setup, evaluating some of the basic features of \CFA's scheduler.
    55
    66\section{Cycling latency}
    77The most basic evaluation of any ready queue is to evaluate the latency needed to push and pop one element from the ready-queue.
    8 While these two operation also describe a \texttt{yield} operation, many systems use this as the most basic benchmark.
    9 However, yielding can be treated as a special case, since it also carries the information that the length of the ready queue will not change.
     8Since these two operation also describe a \texttt{yield} operation, many systems use this as the most basic benchmark.
     9However, yielding can be treated as a special case, since it also carries the information that the number of the ready \glspl{at} will not change.
    1010Not all systems use this information, but those which do may appear to have better performance than they would for disconnected push/pop pairs.
    1111For this reason, I chose a different first benchmark, which I call the Cycle Benchmark.
    12 This benchmark arranges many threads into multiple rings of threads.
     12This benchmark arranges many \glspl{at} into multiple rings of \glspl{at}.
    1313Each ring is effectively a circular singly-linked list.
    14 At runtime, each thread unparks the next thread before parking itself.
     14At runtime, each \gls{at} unparks the next \gls{at} before parking itself.
    1515This corresponds to the desired pair of ready queue operations.
    16 Unparking the next thread requires pushing that thread onto the ready queue and the ensuing park will cause the runtime to pop a thread from the ready-queue.
     16Unparking the next \gls{at} requires pushing that \gls{at} onto the ready queue and the ensuing park will cause the runtime to pop a \gls{at} from the ready-queue.
    1717Figure~\ref{fig:cycle} shows a visual representation of this arrangement.
    1818
    19 The goal of this ring is that the underlying runtime cannot rely on the guarantee that the number of ready threads will stay constant over the duration of the experiment.
    20 In fact, the total number of threads waiting on the ready is expected to vary a little because of the race between the next thread unparking and the current thread parking.
    21 The size of the cycle is also decided based on this race: cycles that are too small may see the
    22 chain of unparks go full circle before the first thread can park.
     19The goal of this ring is that the underlying runtime cannot rely on the guarantee that the number of ready \glspl{at} will stay constant over the duration of the experiment.
     20In fact, the total number of \glspl{at} waiting on the ready queue is expected to vary because of the race between the next \gls{at} unparking and the current \gls{at} parking.
     21The size of the cycle is also decided based on this race: cycles that are too small may see the chain of unparks go full circle before the first \gls{at} can park.
    2322While this would not be a correctness problem, every runtime system must handle that race, it could lead to pushes and pops being optimized away.
    24 Since silently omitting ready-queue operations would throw off the measuring of these operations.
    25 Therefore the ring of threads must be big enough so the threads have the time to fully park before they are unparked.
     23Since silently omitting ready-queue operations would throw off the measuring of these operations, the ring of \glspl{at} must be big enough so the \glspl{at} have the time to fully park before they are unparked.
    2624Note that this problem is only present on SMP machines and is significantly mitigated by the fact that there are multiple rings in the system.
    2725
    … …  
    2927        \centering
    3028        \input{cycle.pstex_t}
    31         \caption[Cycle benchmark]{Cycle benchmark\smallskip\newline Each thread unparks the next thread in the cycle before parking itself.}
     29        \caption[Cycle benchmark]{Cycle benchmark\smallskip\newline Each \gls{at} unparks the next \gls{at} in the cycle before parking itself.}
    3230        \label{fig:cycle}
    3331\end{figure}
    3432
    3533\todo{check term ``idle sleep handling''}
    36 To avoid this benchmark from being dominated by the idle sleep handling, the number of rings is kept at least as high as the number of processors available.
     34To avoid this benchmark from being dominated by the idle sleep handling, the number of rings is kept at least as high as the number of \glspl{proc} available.
    3735Beyond this point, adding more rings serves to mitigate even more the idle sleep handling.
    38 This is to avoid the case where one of the worker threads runs out of work because of the variation on the number of ready threads mentionned above.
     36This is to avoid the case where one of the worker \glspl{at} runs out of work because of the variation on the number of ready \glspl{at} mentionned above.
    3937
    4038The actual benchmark is more complicated to handle termination, but that simply requires using a binary semphore or a channel instead of raw \texttt{park}/\texttt{unpark} and carefully picking the order of the \texttt{P} and \texttt{V} with respect to the loop condition.
    4139
    42 \todo{mention where to get the code.}
     40\todo{code, setup, results}
     41\begin{lstlisting}
     42        Thread.main() {
     43                count := 0
     44                for {
     45                        wait()
     46                        this.next.wake()
     47                        count ++
     48                        if must_stop() { break }
     49                }
     50                global.count += count
     51        }
     52\end{lstlisting}
     53
    4354
    4455\section{Yield}
    4556For completion, I also include the yield benchmark.
    46 This benchmark is much simpler than the cycle tests, it simply creates many threads that call \texttt{yield}.
     57This benchmark is much simpler than the cycle tests, it simply creates many \glspl{at} that call \texttt{yield}.
     58As mentionned in the previous section, this benchmark may be less representative of usages that only make limited use of \texttt{yield}, due to potential shortcuts in the routine.
     59Its only interesting variable is the number of \glspl{at} per \glspl{proc}, where ratios close to 1 means the ready queue(s) could be empty.
     60This sometimes puts more strain on the idle sleep handling, compared to scenarios where there is clearly plenty of work to be done.
     61
     62\todo{code, setup, results}
     63
     64\begin{lstlisting}
     65        Thread.main() {
     66                count := 0
     67                while !stop {
     68                        yield()
     69                        count ++
     70                }
     71                global.count += count
     72        }
     73\end{lstlisting}
     74
     75
     76\section{Churn}
     77The Cycle and Yield benchmark represents an ``easy'' scenario for a scheduler, \eg, an embarrassingly parallel application.
     78In these benchmarks, \glspl{at} can be easily partitioned over the different \glspl{proc} up-front and none of the \glspl{at} communicate with each other.
     79
     80The Churn benchmark represents more chaotic usages, where there is no relation between the last \gls{proc} on which a \gls{at} ran and the \gls{proc} that unblocked it.
     81When a \gls{at} is unblocked from a different \gls{proc} than the one on which it last ran, the unblocking \gls{proc} must either ``steal'' the \gls{at} or place it on a remote queue.
     82This results can result in either contention on the remote queue or \glspl{rmr} on \gls{at} data structure.
     83In either case, this benchmark aims to highlight how each scheduler handles these cases, since both cases can lead to performance degradation if they are not handled correctly.
     84
     85To achieve this the benchmark uses a fixed size array of \newterm{chair}s, where a chair is a data structure that holds a single blocked \gls{at}.
     86When a \gls{at} attempts to block on the chair, it must first unblocked the \gls{at} currently blocked on said chair, if any.
     87This creates a flow where \glspl{at} push each other out of the chairs before being pushed out themselves.
     88For this benchmark to work however, the number of \glspl{at} must be equal or greater to the number of chairs plus the number of \glspl{proc}.
     89
     90\todo{code, setup, results}
     91\begin{lstlisting}
     92        Thread.main() {
     93                count := 0
     94                for {
     95                        r := random() % len(spots)
     96                        next := xchg(spots[r], this)
     97                        if next { next.wake() }
     98                        wait()
     99                        count ++
     100                        if must_stop() { break }
     101                }
     102                global.count += count
     103        }
     104\end{lstlisting}
    47105
    48106\section{Locality}
    49107
     108\todo{code, setup, results}
     109
    50110\section{Transfer}
     111The last benchmark is more exactly characterize as an experiment than a benchmark.
     112It tests the behavior of the schedulers for a particularly misbehaved workload.
     113In this workload, one of the \gls{at} is selected at random to be the leader.
     114The leader then spins in a tight loop until it has observed that all other \glspl{at} have acknowledged its leadership.
     115The leader \gls{at} then picks a new \gls{at} to be the ``spinner'' and the cycle repeats.
     116
     117The benchmark comes in two flavours for the behavior of the non-leader \glspl{at}:
     118once they acknowledged the leader, they either block on a semaphore or yield repeatadly.
     119
     120This experiment is designed to evaluate the short term load balancing of the scheduler.
     121Indeed, schedulers where the runnable \glspl{at} are partitioned on the \glspl{proc} may need to balance the \glspl{at} for this experient to terminate.
     122This is because the spinning \gls{at} is effectively preventing the \gls{proc} from runnning any other \glspl{thrd}.
     123In the semaphore flavour, the number of runnable \glspl{at} will eventually dwindle down to only the leader.
     124This is a simpler case to handle for schedulers since \glspl{proc} eventually run out of work.
     125In the yielding flavour, the number of runnable \glspl{at} stays constant.
     126This is a harder case to handle because corrective measures must be taken even if work is still available.
     127Note that languages that have mandatory preemption do circumvent this problem by forcing the spinner to yield.
     128
     129\todo{code, setup, results}
     130\begin{lstlisting}
     131        Thread.lead() {
     132                this.idx_seen = ++lead_idx
     133                if lead_idx > stop_idx {
     134                        done := true
     135                        return
     136                }
     137
     138                // Wait for everyone to acknowledge my leadership
     139                start: = timeNow()
     140                for t in threads {
     141                        while t.idx_seen != lead_idx {
     142                                asm pause
     143                                if (timeNow() - start) > 5 seconds { error() }
     144                        }
     145                }
     146
     147                // pick next leader
     148                leader := threads[ prng() % len(threads) ]
     149
     150                // wake every one
     151                if !exhaust {
     152                        for t in threads {
     153                                if t != me { t.wake() }
     154                        }
     155                }
     156        }
     157
     158        Thread.wait() {
     159                this.idx_seen := lead_idx
     160                if exhaust { wait() }
     161                else { yield() }
     162        }
     163
     164        Thread.main() {
     165                while !done  {
     166                        if leader == me { this.lead() }
     167                        else { this.wait() }
     168                }
     169        }
     170\end{lstlisting}

  • doc/theses/thierry_delisle_PhD/thesis/text/existing.tex

    r97c215f rf5a51db  
    3333
    3434
    35 \section{Work Stealing}
     35\section{Work Stealing}\label{existing:workstealing}
    3636One of the most popular scheduling algorithm in practice (see~\ref{existing:prod}) is work-stealing. This idea, introduce by \cite{DBLP:conf/fpca/BurtonS81}, effectively has each worker work on its local tasks first, but allows the possibility for other workers to steal local tasks if they run out of tasks. \cite{DBLP:conf/focs/Blumofe94} introduced the more familiar incarnation of this, where each workers has queue of tasks to accomplish and workers without tasks steal tasks from random workers. (The Burton and Sleep algorithm had trees of tasks and stole only among neighbours). Blumofe and Leiserson also prove worst case space and time requirements for well-structured computations.
    3737

  • libcfa/src/concurrency/io.cfa

    r97c215f rf5a51db  
    306306                ctx->proc->io.pending = true;
    307307                ctx->proc->io.dirty   = true;
    308                 if(sq.to_submit > 30 || !lazy) {
     308                if(sq.to_submit > 30) {
     309                        __tls_stats()->io.flush.full++;
     310                        __cfa_io_flush( ctx->proc, 0 );
     311                }
     312                if(!lazy) {
     313                        __tls_stats()->io.flush.eager++;
    309314                        __cfa_io_flush( ctx->proc, 0 );
    310315                }

  • libcfa/src/concurrency/kernel.cfa

    r97c215f rf5a51db  
    4242
    4343#if !defined(__CFA_NO_STATISTICS__)
    44         #define __STATS( ...) __VA_ARGS__
     44        #define __STATS_DEF( ...) __VA_ARGS__
    4545#else
    46         #define __STATS( ...)
     46        #define __STATS_DEF( ...)
    4747#endif
    4848
    … …  
    122122static thread$ * __next_thread(cluster * this);
    123123static thread$ * __next_thread_slow(cluster * this);
     124static thread$ * __next_thread_search(cluster * this);
    124125static inline bool __must_unpark( thread$ * thrd ) __attribute((nonnull(1)));
    125126static void __run_thread(processor * this, thread$ * dst);
    … …  
    187188                MAIN_LOOP:
    188189                for() {
    189                         #define OLD_MAIN 1
    190                         #if OLD_MAIN
    191190                        // Check if there is pending io
    192191                        __maybe_io_drain( this );
    … …  
    196195
    197196                        if( !readyThread ) {
     197                                __IO_STATS__(true, io.flush.idle++; )
    198198                                __cfa_io_flush( this, 0 );
    199199
     200                                readyThread = __next_thread( this->cltr );
     201                        }
     202
     203                        if( !readyThread ) for(5) {
     204                                __IO_STATS__(true, io.flush.idle++; )
     205
    200206                                readyThread = __next_thread_slow( this->cltr );
     207
     208                                if( readyThread ) break;
     209
     210                                __cfa_io_flush( this, 0 );
    201211                        }
    202212
    … …  
    206216                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
    207217
    208                                 #if !defined(__CFA_NO_STATISTICS__)
    209                                         __tls_stats()->ready.sleep.halts++;
    210                                 #endif
    211 
    212218                                // Push self to idle stack
    213219                                if(!mark_idle(this->cltr->procs, * this)) continue MAIN_LOOP;
    214220
    215221                                // Confirm the ready-queue is empty
    216                                 readyThread = __next_thread_slow( this->cltr );
     222                                readyThread = __next_thread_search( this->cltr );
    217223                                if( readyThread ) {
    218224                                        // A thread was found, cancel the halt
    219225                                        mark_awake(this->cltr->procs, * this);
    220226
    221                                         #if !defined(__CFA_NO_STATISTICS__)
    222                                                 __tls_stats()->ready.sleep.cancels++;
    223                                         #endif
     227                                        __STATS__(true, ready.sleep.cancels++; )
    224228
    225229                                        // continue the mai loop
    … …  
    248252
    249253                        if(this->io.pending && !this->io.dirty) {
     254                                __IO_STATS__(true, io.flush.dirty++; )
    250255                                __cfa_io_flush( this, 0 );
    251256                        }
    252 
    253                         #else
    254                                 #warning new kernel loop
    255                         SEARCH: {
    256                                 /* paranoid */ verify( ! __preemption_enabled() );
    257 
    258                                 // First, lock the scheduler since we are searching for a thread
    259                                 ready_schedule_lock();
    260 
    261                                 // Try to get the next thread
    262                                 readyThread = pop_fast( this->cltr );
    263                                 if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    264 
    265                                 // If we can't find a thread, might as well flush any outstanding I/O
    266                                 if(this->io.pending) { __cfa_io_flush( this, 0 ); }
    267 
    268                                 // Spin a little on I/O, just in case
    269                                 for(5) {
    270                                         __maybe_io_drain( this );
    271                                         readyThread = pop_fast( this->cltr );
    272                                         if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    273                                 }
    274 
    275                                 // no luck, try stealing a few times
    276                                 for(5) {
    277                                         if( __maybe_io_drain( this ) ) {
    278                                                 readyThread = pop_fast( this->cltr );
    279                                         } else {
    280                                                 readyThread = pop_slow( this->cltr );
    281                                         }
    282                                         if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    283                                 }
    284 
    285                                 // still no luck, search for a thread
    286                                 readyThread = pop_search( this->cltr );
    287                                 if(readyThread) { ready_schedule_unlock(); break SEARCH; }
    288 
    289                                 // Don't block if we are done
    290                                 if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
    291                                         ready_schedule_unlock();
    292                                         break MAIN_LOOP;
    293                                 }
    294 
    295                                 __STATS( __tls_stats()->ready.sleep.halts++; )
    296 
    297                                 // Push self to idle stack
    298                                 ready_schedule_unlock();
    299                                 if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
    300                                 ready_schedule_lock();
    301 
    302                                 // Confirm the ready-queue is empty
    303                                 __maybe_io_drain( this );
    304                                 readyThread = pop_search( this->cltr );
    305                                 ready_schedule_unlock();
    306 
    307                                 if( readyThread ) {
    308                                         // A thread was found, cancel the halt
    309                                         mark_awake(this->cltr->procs, * this);
    310 
    311                                         __STATS( __tls_stats()->ready.sleep.cancels++; )
    312 
    313                                         // continue the main loop
    314                                         break SEARCH;
    315                                 }
    316 
    317                                 __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
    318                                 __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
    319 
    320                                 {
    321                                         eventfd_t val;
    322                                         ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
    323                                         if(ret < 0) {
    324                                                 switch((int)errno) {
    325                                                 case EAGAIN:
    326                                                 #if EAGAIN != EWOULDBLOCK
    327                                                         case EWOULDBLOCK:
    328                                                 #endif
    329                                                 case EINTR:
    330                                                         // No need to do anything special here, just assume it's a legitimate wake-up
    331                                                         break;
    332                                                 default:
    333                                                         abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
    334                                                 }
    335                                         }
    336                                 }
    337 
    338                                         __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
    339 
    340                                 // We were woken up, remove self from idle
    341                                 mark_awake(this->cltr->procs, * this);
    342 
    343                                 // DON'T just proceed, start looking again
    344                                 continue MAIN_LOOP;
    345                         }
    346 
    347                 RUN_THREAD:
    348                         /* paranoid */ verify( ! __preemption_enabled() );
    349                         /* paranoid */ verify( readyThread );
    350 
    351                         // Reset io dirty bit
    352                         this->io.dirty = false;
    353 
    354                         // We found a thread run it
    355                         __run_thread(this, readyThread);
    356 
    357                         // Are we done?
    358                         if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
    359 
    360                         if(this->io.pending && !this->io.dirty) {
    361                                 __cfa_io_flush( this, 0 );
    362                         }
    363 
    364                         ready_schedule_lock();
    365                         __maybe_io_drain( this );
    366                         ready_schedule_unlock();
    367                         #endif
    368257                }
    369258
    … …  
    476365                                break RUNNING;
    477366                        case TICKET_UNBLOCK:
    478                                 #if !defined(__CFA_NO_STATISTICS__)
    479                                         __tls_stats()->ready.threads.threads++;
    480                                 #endif
     367                                __STATS__(true, ready.threads.threads++; )
    481368                                // This is case 2, the racy case, someone tried to run this thread before it finished blocking
    482369                                // In this case, just run it again.
    … …  
    493380        __cfadbg_print_safe(runtime_core, "Kernel : core %p finished running thread %p\n", this, thrd_dst);
    494381
    495         #if !defined(__CFA_NO_STATISTICS__)
    496                 __tls_stats()->ready.threads.threads--;
    497         #endif
     382        __STATS__(true, ready.threads.threads--; )
    498383
    499384        /* paranoid */ verify( ! __preemption_enabled() );
    … …  
    506391        thread$ * thrd_src = kernelTLS().this_thread;
    507392
    508         __STATS( thrd_src->last_proc = kernelTLS().this_processor; )
     393        __STATS_DEF( thrd_src->last_proc = kernelTLS().this_processor; )
    509394
    510395        // Run the thread on this processor
    … …  
    558443        // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
    559444        struct cluster * cl = thrd->curr_cluster;
    560         __STATS(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
     445        __STATS_DEF(bool outside = hint == UNPARK_LOCAL && thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
    561446
    562447        // push the thread to the cluster ready-queue
    … …  
    609494
    610495        ready_schedule_lock();
    611                 thread$ * thrd;
    612                 for(25) {
    613                         thrd = pop_slow( this );
    614                         if(thrd) goto RET;
    615                 }
    616                 thrd = pop_search( this );
    617 
    618                 RET:
     496                thread$ * thrd = pop_slow( this );
     497        ready_schedule_unlock();
     498
     499        /* paranoid */ verify( ! __preemption_enabled() );
     500        return thrd;
     501}
     502
     503// KERNEL ONLY
     504static inline thread$ * __next_thread_search(cluster * this) with( *this ) {
     505        /* paranoid */ verify( ! __preemption_enabled() );
     506
     507        ready_schedule_lock();
     508                thread$ * thrd = pop_search( this );
    619509        ready_schedule_unlock();
    620510
    … …  
    732622// Wake a thread from the front if there are any
    733623static void __wake_one(cluster * this) {
     624        eventfd_t val;
     625
    734626        /* paranoid */ verify( ! __preemption_enabled() );
    735627        /* paranoid */ verify( ready_schedule_islocked() );
    736628
    737629        // Check if there is a sleeping processor
    738         // int fd = __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST);
    739         int fd = 0;
    740         if( __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST) != 0 ) {
    741                 fd = __atomic_exchange_n(&this->procs.fd, 0, __ATOMIC_RELAXED);
    742         }
    743 
    744         // If no one is sleeping, we are done
    745         if( fd == 0 ) return;
    746 
    747         // We found a processor, wake it up
    748         eventfd_t val;
    749         val = 1;
    750         eventfd_write( fd, val );
    751 
    752         #if !defined(__CFA_NO_STATISTICS__)
    753                 if( kernelTLS().this_stats ) {
    754                         __tls_stats()->ready.sleep.wakes++;
    755                 }
    756                 else {
    757                         __atomic_fetch_add(&this->stats->ready.sleep.wakes, 1, __ATOMIC_RELAXED);
    758                 }
    759         #endif
     630        struct __fd_waitctx * fdp = __atomic_load_n(&this->procs.fdw, __ATOMIC_SEQ_CST);
     631
     632        // If no one is sleeping: we are done
     633        if( fdp == 0p ) return;
     634
     635        int fd = 1;
     636        if( __atomic_load_n(&fdp->fd, __ATOMIC_SEQ_CST) != 1 ) {
     637                fd = __atomic_exchange_n(&fdp->fd, 1, __ATOMIC_RELAXED);
     638        }
     639
     640        switch(fd) {
     641        case 0:
     642                // If the processor isn't ready to sleep then the exchange will already wake it up
     643                #if !defined(__CFA_NO_STATISTICS__)
     644                        if( kernelTLS().this_stats ) { __tls_stats()->ready.sleep.early++;
     645                        } else { __atomic_fetch_add(&this->stats->ready.sleep.early, 1, __ATOMIC_RELAXED); }
     646                #endif
     647                break;
     648        case 1:
     649                // If someone else already said they will wake them: we are done
     650                #if !defined(__CFA_NO_STATISTICS__)
     651                        if( kernelTLS().this_stats ) { __tls_stats()->ready.sleep.seen++;
     652                        } else { __atomic_fetch_add(&this->stats->ready.sleep.seen, 1, __ATOMIC_RELAXED); }
     653                #endif
     654                break;
     655        default:
     656                // If the processor was ready to sleep, we need to wake it up with an actual write
     657                val = 1;
     658                eventfd_write( fd, val );
     659
     660                #if !defined(__CFA_NO_STATISTICS__)
     661                        if( kernelTLS().this_stats ) { __tls_stats()->ready.sleep.wakes++;
     662                        } else { __atomic_fetch_add(&this->stats->ready.sleep.wakes, 1, __ATOMIC_RELAXED); }
     663                #endif
     664                break;
     665        }
    760666
    761667        /* paranoid */ verify( ready_schedule_islocked() );
    … …  
    770676
    771677        __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
     678
     679        this->idle_wctx.fd = 1;
    772680
    773681        eventfd_t val;
    … …  
    779687
    780688static void idle_sleep(processor * this, io_future_t & future, iovec & iov) {
     689        // Tell everyone we are ready to go do sleep
     690        for() {
     691                int expected = this->idle_wctx.fd;
     692
     693                // Someone already told us to wake-up! No time for a nap.
     694                if(expected == 1) { return; }
     695
     696                // Try to mark that we are going to sleep
     697                if(__atomic_compare_exchange_n(&this->idle_wctx.fd, &expected, this->idle_fd, false,  __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ) {
     698                        // Every one agreed, taking a nap
     699                        break;
     700                }
     701        }
     702
     703
    781704        #if !defined(CFA_WITH_IO_URING_IDLE)
    782705                #if !defined(__CFA_NO_STATISTICS__)
    … …  
    825748
    826749static bool mark_idle(__cluster_proc_list & this, processor & proc) {
     750        __STATS__(true, ready.sleep.halts++; )
     751
     752        proc.idle_wctx.fd = 0;
     753
    827754        /* paranoid */ verify( ! __preemption_enabled() );
    828755        if(!try_lock( this )) return false;
    … …  
    832759                insert_first(this.idles, proc);
    833760
    834                 __atomic_store_n(&this.fd, proc.idle_fd, __ATOMIC_SEQ_CST);
     761                __atomic_store_n(&this.fdw, &proc.idle_wctx, __ATOMIC_SEQ_CST);
    835762        unlock( this );
    836763        /* paranoid */ verify( ! __preemption_enabled() );
    … …  
    848775
    849776                {
    850                         int fd = 0;
    851                         if(!this.idles`isEmpty) fd = this.idles`first.idle_fd;
    852                         __atomic_store_n(&this.fd, fd, __ATOMIC_SEQ_CST);
     777                        struct __fd_waitctx * wctx = 0;
     778                        if(!this.idles`isEmpty) wctx = &this.idles`first.idle_wctx;
     779                        __atomic_store_n(&this.fdw, wctx, __ATOMIC_SEQ_CST);
    853780                }
    854781
    … …  
    914841                unsigned tail = *ctx->cq.tail;
    915842                if(head == tail) return false;
    916                 #if OLD_MAIN
    917                         ready_schedule_lock();
    918                         ret = __cfa_io_drain( proc );
    919                         ready_schedule_unlock();
    920                 #else
    921                         ret = __cfa_io_drain( proc );
    922                 #endif
     843                ready_schedule_lock();
     844                ret = __cfa_io_drain( proc );
     845                ready_schedule_unlock();
    923846        #endif
    924847        return ret;

  • libcfa/src/concurrency/kernel.hfa

    r97c215f rf5a51db  
    5353coroutine processorCtx_t {
    5454        struct processor * proc;
     55};
     56
     57
     58struct __fd_waitctx {
     59        volatile int fd;
    5560};
    5661
    … …  
    101106        int idle_fd;
    102107
     108        // Idle waitctx
     109        struct __fd_waitctx idle_wctx;
     110
    103111        // Termination synchronisation (user semaphore)
    104112        oneshot terminated;
    … …  
    207215
    208216        // FD to use to wake a processor
    209         volatile int fd;
     217        struct __fd_waitctx * volatile fdw;
    210218
    211219        // Total number of processors

  • libcfa/src/concurrency/kernel/fwd.hfa

    r97c215f rf5a51db  
    396396                                if( !(in_kernel) ) enable_interrupts(); \
    397397                        }
     398                        #if defined(CFA_HAVE_LINUX_IO_URING_H)
     399                                #define __IO_STATS__(in_kernel, ...) { \
     400                                        if( !(in_kernel) ) disable_interrupts(); \
     401                                        with( *__tls_stats() ) { \
     402                                                __VA_ARGS__ \
     403                                        } \
     404                                        if( !(in_kernel) ) enable_interrupts(); \
     405                                }
     406                        #else
     407                                #define __IO_STATS__(in_kernel, ...)
     408                        #endif
    398409                #else
    399410                        #define __STATS__(in_kernel, ...)
     411                        #define __IO_STATS__(in_kernel, ...)
    400412                #endif
    401413        }

  • libcfa/src/concurrency/kernel/startup.cfa

    r97c215f rf5a51db  
    537537        }
    538538
     539        this.idle_wctx.fd = 0;
     540
     541        // I'm assuming these two are reserved for standard input and output
     542        // so I'm using them as sentinels with idle_wctx.
     543        /* paranoid */ verify( this.idle_fd != 0 );
     544        /* paranoid */ verify( this.idle_fd != 1 );
     545
    539546        #if !defined(__CFA_NO_STATISTICS__)
    540547                print_stats = 0;
    … …  
    590597// Cluster
    591598static void ?{}(__cluster_proc_list & this) {
    592         this.fd    = 0;
     599        this.fdw   = 0p;
    593600        this.idle  = 0;
    594601        this.total = 0;

  • libcfa/src/concurrency/mutex_stmt.hfa

    r97c215f rf5a51db  
    3838    }
    3939
     40    struct scoped_lock {
     41        L * internal_lock;
     42    };
     43
     44    static inline void ?{}( scoped_lock(L) & this, L & internal_lock ) {
     45        this.internal_lock = &internal_lock;
     46        lock(internal_lock);
     47    }
     48   
     49    static inline void ^?{}( scoped_lock(L) & this ) with(this) {
     50        unlock(*internal_lock);
     51    }
     52
    4053    static inline L * __get_ptr( L & this ) {
    4154        return &this;

  • libcfa/src/concurrency/preemption.cfa

    r97c215f rf5a51db  
    251251        bool enabled = __cfaabi_tls.preemption_state.enabled;
    252252
     253        // Check if there is a pending preemption
     254        processor   * proc = __cfaabi_tls.this_processor;
     255        bool pending = proc ? proc->pending_preemption : false;
     256        if( enabled && pending ) proc->pending_preemption = false;
     257
    253258        // create a assembler label after
    254259        // marked as clobber all to avoid movement
    255260        __cfaasm_label(check, after);
     261
     262        // If we can preempt and there is a pending one
     263        // this is a good time to yield
     264        if( enabled && pending ) {
     265                force_yield( __POLL_PREEMPTION );
     266        }
    256267        return enabled;
    257268}
    … …  
    282293        // marked as clobber all to avoid movement
    283294        __cfaasm_label(get, after);
     295
     296        // This is used everywhere, to avoid cost, we DO NOT poll pending preemption
    284297        return val;
    285298}
    … …  
    358371        if(!ready) { abort("Preemption should be ready"); }
    359372
    360         __cfaasm_label(debug, before);
    361 
    362                 sigset_t oldset;
    363                 int ret;
    364                 ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
    365                 if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
    366 
    367                 ret = sigismember(&oldset, SIGUSR1);
    368                 if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
    369                 if(ret == 1) { abort("ERROR SIGUSR1 is disabled"); }
    370 
    371                 ret = sigismember(&oldset, SIGALRM);
    372                 if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
    373                 if(ret == 0) { abort("ERROR SIGALRM is enabled"); }
    374 
    375                 ret = sigismember(&oldset, SIGTERM);
    376                 if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
    377                 if(ret == 1) { abort("ERROR SIGTERM is disabled"); }
    378 
    379         __cfaasm_label(debug, after);
     373        sigset_t oldset;
     374        int ret;
     375        ret = pthread_sigmask(0, ( const sigset_t * ) 0p, &oldset);  // workaround trac#208: cast should be unnecessary
     376        if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
     377
     378        ret = sigismember(&oldset, SIGUSR1);
     379        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
     380        if(ret == 1) { abort("ERROR SIGUSR1 is disabled"); }
     381
     382        ret = sigismember(&oldset, SIGALRM);
     383        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
     384        if(ret == 0) { abort("ERROR SIGALRM is enabled"); }
     385
     386        ret = sigismember(&oldset, SIGTERM);
     387        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
     388        if(ret == 1) { abort("ERROR SIGTERM is disabled"); }
    380389}
    381390
    … …  
    548557        __cfaasm_label( check  );
    549558        __cfaasm_label( dsable );
    550         __cfaasm_label( debug  );
     559        // __cfaasm_label( debug  );
    551560
    552561        // Check if preemption is safe
    … …  
    555564        if( __cfaasm_in( ip, check  ) ) { ready = false; goto EXIT; };
    556565        if( __cfaasm_in( ip, dsable ) ) { ready = false; goto EXIT; };
    557         if( __cfaasm_in( ip, debug  ) ) { ready = false; goto EXIT; };
     566        // if( __cfaasm_in( ip, debug  ) ) { ready = false; goto EXIT; };
    558567        if( !__cfaabi_tls.preemption_state.enabled) { ready = false; goto EXIT; };
    559568        if( __cfaabi_tls.preemption_state.in_progress ) { ready = false; goto EXIT; };
    … …  
    661670
    662671        // Check if it is safe to preempt here
    663         if( !preemption_ready( ip ) ) { return; }
     672        if( !preemption_ready( ip ) ) {
     673                #if !defined(__CFA_NO_STATISTICS__)
     674                        __cfaabi_tls.this_stats->ready.threads.preempt.rllfwd++;
     675                #endif
     676                return;
     677        }
    664678
    665679        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", __cfaabi_tls.this_processor, __cfaabi_tls.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
    … …  
    680694
    681695        // Preemption can occur here
     696
     697        #if !defined(__CFA_NO_STATISTICS__)
     698                __cfaabi_tls.this_stats->ready.threads.preempt.yield++;
     699        #endif
    682700
    683701        force_yield( __ALARM_PREEMPTION ); // Do the actual __cfactx_switch

  • libcfa/src/concurrency/ready_queue.cfa

    r97c215f rf5a51db  
    201201uint_fast32_t ready_mutate_lock( void ) with(*__scheduler_lock) {
    202202        /* paranoid */ verify( ! __preemption_enabled() );
    203         /* paranoid */ verify( ! kernelTLS().sched_lock );
    204203
    205204        // Step 1 : lock global lock
    … …  
    207206        //   to simply lock their own lock and enter.
    208207        __atomic_acquire( &write_lock );
     208
     209        // Make sure we won't deadlock ourself
     210        // Checking before acquiring the writer lock isn't safe
     211        // because someone else could have locked us.
     212        /* paranoid */ verify( ! kernelTLS().sched_lock );
    209213
    210214        // Step 2 : lock per-proc lock

  • libcfa/src/concurrency/stats.cfa

    r97c215f rf5a51db  
    2929                stats->ready.threads.threads   = 0;
    3030                stats->ready.threads.cthreads  = 0;
     31                stats->ready.threads.preempt.yield  = 0;
     32                stats->ready.threads.preempt.rllfwd = 0;
    3133                stats->ready.sleep.halts   = 0;
    3234                stats->ready.sleep.cancels = 0;
     35                stats->ready.sleep.early   = 0;
    3336                stats->ready.sleep.wakes   = 0;
     37                stats->ready.sleep.seen    = 0;
    3438                stats->ready.sleep.exits   = 0;
    3539
    … …  
    4347                        stats->io.submit.slow       = 0;
    4448                        stats->io.flush.external    = 0;
     49                        stats->io.flush.dirty       = 0;
     50                        stats->io.flush.full        = 0;
     51                        stats->io.flush.idle        = 0;
     52                        stats->io.flush.eager       = 0;
    4553                        stats->io.calls.flush       = 0;
    4654                        stats->io.calls.submitted   = 0;
    … …  
    7179
    7280        void __tally_stats( struct __stats_t * cltr, struct __stats_t * proc ) {
    73                 tally_one( &cltr->ready.push.local.attempt, &proc->ready.push.local.attempt );
    74                 tally_one( &cltr->ready.push.local.success, &proc->ready.push.local.success );
    75                 tally_one( &cltr->ready.push.share.attempt, &proc->ready.push.share.attempt );
    76                 tally_one( &cltr->ready.push.share.success, &proc->ready.push.share.success );
    77                 tally_one( &cltr->ready.push.extrn.attempt, &proc->ready.push.extrn.attempt );
    78                 tally_one( &cltr->ready.push.extrn.success, &proc->ready.push.extrn.success );
    79                 tally_one( &cltr->ready.pop.local .attempt, &proc->ready.pop.local .attempt );
    80                 tally_one( &cltr->ready.pop.local .success, &proc->ready.pop.local .success );
    81                 tally_one( &cltr->ready.pop.help  .attempt, &proc->ready.pop.help  .attempt );
    82                 tally_one( &cltr->ready.pop.help  .success, &proc->ready.pop.help  .success );
    83                 tally_one( &cltr->ready.pop.steal .attempt, &proc->ready.pop.steal .attempt );
    84                 tally_one( &cltr->ready.pop.steal .success, &proc->ready.pop.steal .success );
    85                 tally_one( &cltr->ready.pop.search.attempt, &proc->ready.pop.search.attempt );
    86                 tally_one( &cltr->ready.pop.search.success, &proc->ready.pop.search.success );
    87                 tally_one( &cltr->ready.threads.migration , &proc->ready.threads.migration  );
    88                 tally_one( &cltr->ready.threads.extunpark , &proc->ready.threads.extunpark  );
    89                 tally_one( &cltr->ready.threads.threads   , &proc->ready.threads.threads    );
    90                 tally_one( &cltr->ready.threads.cthreads  , &proc->ready.threads.cthreads   );
    91                 tally_one( &cltr->ready.sleep.halts       , &proc->ready.sleep.halts        );
    92                 tally_one( &cltr->ready.sleep.cancels     , &proc->ready.sleep.cancels      );
    93                 tally_one( &cltr->ready.sleep.wakes       , &proc->ready.sleep.wakes        );
    94                 tally_one( &cltr->ready.sleep.exits       , &proc->ready.sleep.exits        );
     81                tally_one( &cltr->ready.push.local.attempt    , &proc->ready.push.local.attempt     );
     82                tally_one( &cltr->ready.push.local.success    , &proc->ready.push.local.success     );
     83                tally_one( &cltr->ready.push.share.attempt    , &proc->ready.push.share.attempt     );
     84                tally_one( &cltr->ready.push.share.success    , &proc->ready.push.share.success     );
     85                tally_one( &cltr->ready.push.extrn.attempt    , &proc->ready.push.extrn.attempt     );
     86                tally_one( &cltr->ready.push.extrn.success    , &proc->ready.push.extrn.success     );
     87                tally_one( &cltr->ready.pop.local .attempt    , &proc->ready.pop.local .attempt     );
     88                tally_one( &cltr->ready.pop.local .success    , &proc->ready.pop.local .success     );
     89                tally_one( &cltr->ready.pop.help  .attempt    , &proc->ready.pop.help  .attempt     );
     90                tally_one( &cltr->ready.pop.help  .success    , &proc->ready.pop.help  .success     );
     91                tally_one( &cltr->ready.pop.steal .attempt    , &proc->ready.pop.steal .attempt     );
     92                tally_one( &cltr->ready.pop.steal .success    , &proc->ready.pop.steal .success     );
     93                tally_one( &cltr->ready.pop.search.attempt    , &proc->ready.pop.search.attempt     );
     94                tally_one( &cltr->ready.pop.search.success    , &proc->ready.pop.search.success     );
     95                tally_one( &cltr->ready.threads.migration     , &proc->ready.threads.migration      );
     96                tally_one( &cltr->ready.threads.extunpark     , &proc->ready.threads.extunpark      );
     97                tally_one( &cltr->ready.threads.threads       , &proc->ready.threads.threads        );
     98                tally_one( &cltr->ready.threads.cthreads      , &proc->ready.threads.cthreads       );
     99                tally_one( &cltr->ready.threads.preempt.yield , &proc->ready.threads.preempt.yield  );
     100                tally_one( &cltr->ready.threads.preempt.rllfwd, &proc->ready.threads.preempt.rllfwd );
     101                tally_one( &cltr->ready.sleep.halts           , &proc->ready.sleep.halts            );
     102                tally_one( &cltr->ready.sleep.cancels         , &proc->ready.sleep.cancels          );
     103                tally_one( &cltr->ready.sleep.early           , &proc->ready.sleep.early            );
     104                tally_one( &cltr->ready.sleep.wakes           , &proc->ready.sleep.wakes            );
     105                tally_one( &cltr->ready.sleep.seen            , &proc->ready.sleep.wakes            );
     106                tally_one( &cltr->ready.sleep.exits           , &proc->ready.sleep.exits            );
    95107
    96108                #if defined(CFA_HAVE_LINUX_IO_URING_H)
    … …  
    103115                        tally_one( &cltr->io.submit.slow      , &proc->io.submit.slow       );
    104116                        tally_one( &cltr->io.flush.external   , &proc->io.flush.external    );
     117                        tally_one( &cltr->io.flush.dirty      , &proc->io.flush.dirty       );
     118                        tally_one( &cltr->io.flush.full       , &proc->io.flush.full        );
     119                        tally_one( &cltr->io.flush.idle       , &proc->io.flush.idle        );
     120                        tally_one( &cltr->io.flush.eager      , &proc->io.flush.eager       );
    105121                        tally_one( &cltr->io.calls.flush      , &proc->io.calls.flush       );
    106122                        tally_one( &cltr->io.calls.submitted  , &proc->io.calls.submitted   );
    … …  
    153169                             | " (" | eng3(ready.pop.search.attempt) | " try)";
    154170
    155                         sstr | "- Idle Slp : " | eng3(ready.sleep.halts) | "halt," | eng3(ready.sleep.cancels) | "cancel," | eng3(ready.sleep.wakes) | "wake," | eng3(ready.sleep.exits) | "exit";
     171                        sstr | "- Idle Slp : " | eng3(ready.sleep.halts) | "halt," | eng3(ready.sleep.cancels) | "cancel,"
     172                             | eng3(ready.sleep.wakes + ready.sleep.early) | '(' | eng3(ready.sleep.early) | ',' | eng3(ready.sleep.seen) | ')' | " wake(early, seen),"
     173                             | eng3(ready.sleep.exits) | "exit";
     174                        sstr | "- Preemption : " | eng3(ready.threads.preempt.yield) | "yields," | eng3(ready.threads.preempt.rllfwd) | "delayed";
    156175                        sstr | nl;
    157176                }
    … …  
    178197                                if(io.alloc.fail || io.alloc.revoke || io.alloc.block)
    179198                                        sstr | "-     failures      : " | eng3(io.alloc.fail) | "oom, " | eng3(io.alloc.revoke) | "rvk, " | eng3(io.alloc.block) | "blk";
    180                                 if(io.flush.external)
    181                                         sstr | "- flush external    : " | eng3(io.flush.external);
     199                                // if(io.flush.external)
     200                                //      sstr | "- flush external    : " | eng3(io.flush.external);
    182201
    183202                                double avgsubs = ((double)io.calls.submitted) / io.calls.flush;
    184203                                double avgcomp = ((double)io.calls.completed) / io.calls.drain;
    185204                                sstr | "- syscll : "
    186                                      |   " sub " | eng3(io.calls.flush) | "/" | eng3(io.calls.submitted) | "(" | ws(3, 3, avgsubs) | "/flush)"
    187                                      | " - cmp " | eng3(io.calls.drain) | "/" | eng3(io.calls.completed) | "(" | ws(3, 3, avgcomp) | "/drain)"
     205                                     |   " sub " | eng3(io.calls.submitted) | "/" | eng3(io.calls.flush) | "(" | ws(3, 3, avgsubs) | "/flush)"
     206                                     | " - cmp " | eng3(io.calls.completed) | "/" | eng3(io.calls.drain) | "(" | ws(3, 3, avgcomp) | "/drain)"
    188207                                     | " - " | eng3(io.calls.errors.busy) | " EBUSY";
     208                                sstr | " - sub: " | eng3(io.flush.full) | "full, " | eng3(io.flush.dirty) | "drty, " | eng3(io.flush.idle) | "idle, " | eng3(io.flush.eager) | "eagr, " | eng3(io.flush.external) | "ext";
    189209                                sstr | "- ops blk: "
    190210                                     |   " sk rd: " | eng3(io.ops.sockread)  | "epll: " | eng3(io.ops.epllread)

  • libcfa/src/concurrency/stats.hfa

    r97c215f rf5a51db  
    6565                        volatile  int64_t threads;  // number of threads in the system, includes only local change
    6666                        volatile  int64_t cthreads; // number of threads in the system, includes only local change
     67                        struct {
     68                                volatile uint64_t yield;
     69                                volatile uint64_t rllfwd;
     70                        } preempt;
    6771                } threads;
    6872                struct {
    6973                        volatile uint64_t halts;
    7074                        volatile uint64_t cancels;
     75                        volatile uint64_t early;
    7176                        volatile uint64_t wakes;
     77                        volatile uint64_t seen;
    7278                        volatile uint64_t exits;
    7379                } sleep;
    … …  
    8995                        struct {
    9096                                volatile uint64_t external;
     97                                volatile uint64_t dirty;
     98                                volatile uint64_t full;
     99                                volatile uint64_t idle;
     100                                volatile uint64_t eager;
    91101                        } flush;
    92102                        struct {

  • libcfa/src/stdhdr/pthread.h

    r97c215f rf5a51db  
    1010// Created On       : Wed Jun 16 13:39:06 2021
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jun 16 13:39:42 2021
    13 // Update Count     : 1
     12// Last Modified On : Thu Feb  3 21:53:26 2022
     13// Update Count     : 13
    1414//
    1515
     16// pthread.h and setjmp.h cannot agree on the type of __sigsetjmp:
     17//
     18//   extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) __attribute__ ((__nothrow__));
     19//   extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) __attribute__ ((__nothrow__));
     20//
     21// With -Wall, gcc-11 warns about the disagreement unless the CPP directive
     22//
     23//    # 1 "/usr/include/pthread.h" 1 3 4
     24//
     25// appears, which appears to be witchcraft. Unfortunately, this directive is removed by the CFA preprocessor, so the
     26// batchtest fails because of the spurious warning message. Hence, the warning is elided.
     27
    1628extern "C" {
     29#if defined(__GNUC__) && __GNUC__ == 11
     30        #pragma GCC diagnostic push
     31        #pragma GCC diagnostic ignored "-Warray-parameter"
     32#endif // defined(__GNUC__) && __GNUC__ == 11
     33
    1734#include_next <pthread.h>                                                               // has internal check for multiple expansion
     35
     36#if defined(__GNUC__) && __GNUC__ == 11
     37        #pragma GCC diagnostic pop
     38#endif // defined(__GNUC__) && __GNUC__ == 11
    1839} // extern "C"
    1940
    2041// Local Variables: //
    21 // tab-width: 4 //
    2242// mode: c++ //
    23 // compile-command: "make install" //
    2443// End: //

  • libcfa/src/stdhdr/setjmp.h

    r97c215f rf5a51db  
    1010// Created On       : Mon Jul  4 23:25:26 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Tue Jul  5 20:38:33 2016
    13 // Update Count     : 12
     12// Last Modified On : Thu Feb  3 21:53:28 2022
     13// Update Count     : 18
    1414//
    1515
     16// pthread.h and setjmp.h cannot agree on the type of __sigsetjmp:
     17//
     18//   extern int __sigsetjmp (struct __jmp_buf_tag *__env, int __savemask) __attribute__ ((__nothrow__));
     19//   extern int __sigsetjmp (struct __jmp_buf_tag __env[1], int __savemask) __attribute__ ((__nothrow__));
     20//
     21// With -Wall, gcc-11 warns about the disagreement unless the CPP directive
     22//
     23//    # 1 "/usr/include/pthread.h" 1 3 4
     24//
     25// appears, which appears to be witchcraft. Unfortunately, this directive is removed by the CFA preprocessor, so the
     26// batchtest fails because of the spurious warning message. Hence, the warning is elided.
     27
    1628extern "C" {
     29#if defined(__GNUC__) && __GNUC__ == 11
     30        #pragma GCC diagnostic push
     31        #pragma GCC diagnostic ignored "-Warray-parameter"
     32#endif // defined(__GNUC__) && __GNUC__ == 11
     33
    1734#include_next <setjmp.h>                                                                // has internal check for multiple expansion
     35
     36#if defined(__GNUC__) && __GNUC__ == 11
     37        #pragma GCC diagnostic pop
     38#endif // defined(__GNUC__) && __GNUC__ == 11
    1839} // extern "C"
    1940
    2041// Local Variables: //
    21 // tab-width: 4 //
    2242// mode: c++ //
    23 // compile-command: "make install" //
    2443// End: //

  • src/AST/Convert.cpp

    r97c215f rf5a51db  
    99// Author           : Thierry Delisle
    1010// Created On       : Thu May 09 15::37::05 2019
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jul 14 16:15:00 2021
    13 // Update Count     : 37
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Feb  2 13:19:22 2022
     13// Update Count     : 41
    1414//
    1515
    … …  
    393393                auto stmt = new IfStmt(
    394394                        get<Expression>().accept1( node->cond ),
    395                         get<Statement>().accept1( node->thenPart ),
    396                         get<Statement>().accept1( node->elsePart ),
     395                        get<Statement>().accept1( node->then ),
     396                        get<Statement>().accept1( node->else_ ),
    397397                        get<Statement>().acceptL( node->inits )
    398398                );
    … …  
    419419        }
    420420
    421         const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
     421        const ast::Stmt * visit( const ast::WhileDoStmt * node ) override final {
    422422                if ( inCache( node ) ) return nullptr;
    423423                auto inits = get<Statement>().acceptL( node->inits );
    424                 auto stmt = new WhileStmt(
     424                auto stmt = new WhileDoStmt(
    425425                        get<Expression>().accept1( node->cond ),
    426426                        get<Statement>().accept1( node->body ),
     427                        get<Statement>().accept1( node->else_ ),
    427428                        inits,
    428429                        node->isDoWhile
    … …  
    437438                        get<Expression>().accept1( node->cond ),
    438439                        get<Expression>().accept1( node->inc ),
    439                         get<Statement>().accept1( node->body )
     440                        get<Statement>().accept1( node->body ),
     441                        get<Statement>().accept1( node->else_ )
    440442                );
    441443                return stmtPostamble( stmt, node );
    … …  
    18721874                        old->location,
    18731875                        GET_ACCEPT_1(condition, Expr),
    1874                         GET_ACCEPT_1(thenPart, Stmt),
    1875                         GET_ACCEPT_1(elsePart, Stmt),
     1876                        GET_ACCEPT_1(then, Stmt),
     1877                        GET_ACCEPT_1(else_, Stmt),
    18761878                        GET_ACCEPT_V(initialization, Stmt),
    18771879                        GET_LABELS_V(old->labels)
    … …  
    19021904        }
    19031905
    1904         virtual void visit( const WhileStmt * old ) override final {
     1906        virtual void visit( const WhileDoStmt * old ) override final {
    19051907                if ( inCache( old ) ) return;
    1906                 this->node = new ast::WhileStmt(
     1908                this->node = new ast::WhileDoStmt(
    19071909                        old->location,
    19081910                        GET_ACCEPT_1(condition, Expr),
    19091911                        GET_ACCEPT_1(body, Stmt),
     1912                        GET_ACCEPT_1(else_, Stmt),
    19101913                        GET_ACCEPT_V(initialization, Stmt),
    19111914                        old->isDoWhile,
    … …  
    19231926                        GET_ACCEPT_1(increment, Expr),
    19241927                        GET_ACCEPT_1(body, Stmt),
     1928                        GET_ACCEPT_1(else_, Stmt),
    19251929                        GET_LABELS_V(old->labels)
    19261930                );

  • src/AST/Copy.hpp

    r97c215f rf5a51db  
    1010// Created On       : Wed Jul 10 16:13:00 2019
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Thr Nov 11  9:22:00 2021
    13 // Update Count     : 2
     12// Last Modified On : Wed Dec 15 11:07:00 2021
     13// Update Count     : 3
    1414//
    1515
    … …  
    5252Node * deepCopy<Node>( const Node * localRoot );
    5353
     54template<typename node_t, enum Node::ref_type ref_t>
     55node_t * shallowCopy( const ptr_base<node_t, ref_t> & localRoot ) {
     56        return shallowCopy( localRoot.get() );
     57}
     58
     59template<typename node_t, enum Node::ref_type ref_t>
     60node_t * deepCopy( const ptr_base<node_t, ref_t> & localRoot ) {
     61        return deepCopy( localRoot.get() );
     62}
     63
    5464}
    5565

  • src/AST/Fwd.hpp

    r97c215f rf5a51db  
    1010// Created On       : Wed May  8 16:05:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:37:39 2021
    13 // Update Count     : 4
     12// Last Modified On : Tue Feb  1 09:08:33 2022
     13// Update Count     : 5
    1414//
    1515
    … …  
    4444class DirectiveStmt;
    4545class IfStmt;
    46 class WhileStmt;
     46class WhileDoStmt;
    4747class ForStmt;
    4848class SwitchStmt;

  • src/AST/Node.cpp

    r97c215f rf5a51db  
    1010// Created On       : Thu May 16 14:16:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:25:06 2021
    13 // Update Count     : 2
     12// Last Modified On : Tue Feb  1 09:09:39 2022
     13// Update Count     : 3
    1414//
    1515
    … …  
    146146template class ast::ptr_base< ast::IfStmt, ast::Node::ref_type::weak >;
    147147template class ast::ptr_base< ast::IfStmt, ast::Node::ref_type::strong >;
    148 template class ast::ptr_base< ast::WhileStmt, ast::Node::ref_type::weak >;
    149 template class ast::ptr_base< ast::WhileStmt, ast::Node::ref_type::strong >;
     148template class ast::ptr_base< ast::WhileDoStmt, ast::Node::ref_type::weak >;
     149template class ast::ptr_base< ast::WhileDoStmt, ast::Node::ref_type::strong >;
    150150template class ast::ptr_base< ast::ForStmt, ast::Node::ref_type::weak >;
    151151template class ast::ptr_base< ast::ForStmt, ast::Node::ref_type::strong >;

  • src/AST/Node.hpp

    r97c215f rf5a51db  
    188188        }
    189189
     190        ptr_base & operator=( const node_t * node ) {
     191                assign( node );
     192                return *this;
     193        }
     194
    190195        template<typename o_node_t>
    191196        ptr_base & operator=( const o_node_t * node ) {

  • src/AST/Pass.hpp

    r97c215f rf5a51db  
    146146        const ast::Stmt *             visit( const ast::DirectiveStmt        * ) override final;
    147147        const ast::Stmt *             visit( const ast::IfStmt               * ) override final;
    148         const ast::Stmt *             visit( const ast::WhileStmt            * ) override final;
     148        const ast::Stmt *             visit( const ast::WhileDoStmt          * ) override final;
    149149        const ast::Stmt *             visit( const ast::ForStmt              * ) override final;
    150150        const ast::Stmt *             visit( const ast::SwitchStmt           * ) override final;
    … …  
    238238
    239239private:
    240         const ast::Stmt * call_accept( const ast::Stmt * );
    241         const ast::Expr * call_accept( const ast::Expr * );
    242 
    243         // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
    244 
    245         const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
    246 
     240
     241        // Regular nodes
    247242        template< typename node_t >
    248         auto call_accept( const node_t * node ) -> typename std::enable_if<
     243        struct result1 {
     244                bool differs;
     245                const node_t * value;
     246
     247                template< typename object_t, typename super_t, typename field_t >
     248                void apply(object_t *, field_t super_t::* field);
     249        };
     250
     251        result1<ast::Stmt> call_accept( const ast::Stmt * );
     252        result1<ast::Expr> call_accept( const ast::Expr * );
     253
     254        template< typename node_t >
     255        auto call_accept( const node_t * node )
     256                -> typename std::enable_if<
    249257                                !std::is_base_of<ast::Expr, node_t>::value &&
    250258                                !std::is_base_of<ast::Stmt, node_t>::value
    251                         , decltype( node->accept(*this) )
     259                        , result1<
     260                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
     261                        >
    252262                >::type;
    253263
     264        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
     265        result1<ast::Stmt> call_accept_as_compound(const ast::Stmt *);
     266
     267        template<typename it_t, template <class...> class container_t>
     268                static inline void take_all_delta( it_t it, container_t<ast::ptr<ast::Decl>> * decls, bool * mutated = nullptr ) {
     269                        if(empty(decls)) return;
     270
     271                        std::transform(decls->begin(), decls->end(), it, [](ast::ptr<ast::Decl>&& decl) -> auto {
     272                                        auto loc = decl->location;
     273                                        auto stmt = new DeclStmt( loc, decl.release() );
     274                                        return { {stmt}, -1, false };
     275                                });
     276                        decls->clear();
     277                        if(mutated) *mutated = true;
     278                }
     279
     280        // Container of statements
    254281        template< template <class...> class container_t >
    255         container_t< ptr<Stmt> > call_accept( const container_t< ptr<Stmt> > & );
    256 
     282        struct resultNstmt {
     283                struct delta {
     284                        ptr<Stmt> nval;
     285                        ssize_t old_idx;
     286                        bool is_old;
     287
     288                        delta(const Stmt * s, ssize_t i, bool old) : nval{s}, old_idx{i}, is_old{old} {}
     289                };
     290
     291                bool differs;
     292                container_t< delta > values;
     293
     294                resultNstmt() : differs(false), values{} {}
     295                resultNstmt(bool diff, container_t< delta > && vals) : differs(diff), values(vals) {}
     296
     297                template< typename object_t, typename super_t, typename field_t >
     298                void apply(object_t *, field_t super_t::* field);
     299
     300                template< template <class...> class incontainer_t >
     301                void take_all( incontainer_t<ast::ptr<ast::Stmt>> * stmts ) {
     302                        if(!stmts || stmts->empty()) return;
     303
     304                        std::transform(stmts->begin(), stmts->end(), std::back_inserter( values ), [](ast::ptr<ast::Stmt>& decl) -> delta {
     305                                        return delta( decl.release(), -1, false );
     306                                });
     307                        stmts->clear();
     308                        differs = true;
     309                }
     310
     311                template< template <class...> class incontainer_t >
     312                void take_all( incontainer_t<ast::ptr<ast::Decl>> * decls ) {
     313                        if(!decls || decls->empty()) return;
     314
     315                        std::transform(decls->begin(), decls->end(), std::back_inserter( values ), [](ast::ptr<ast::Decl>& decl) -> auto {
     316                                        auto loc = decl->location;
     317                                        auto stmt = new DeclStmt( loc, decl.release() );
     318                                        return delta( stmt, -1, false );
     319                                });
     320                        decls->clear();
     321                        differs = true;
     322                }
     323        };
     324
     325        template< template <class...> class container_t >
     326        resultNstmt<container_t> call_accept( const container_t< ptr<Stmt> > & );
     327
     328        // Container of something
    257329        template< template <class...> class container_t, typename node_t >
    258         container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
     330        struct resultN {
     331                bool differs;
     332                container_t<ptr<node_t>> values;
     333
     334                template< typename object_t, typename super_t, typename field_t >
     335                void apply(object_t *, field_t super_t::* field);
     336        };
     337
     338        template< template <class...> class container_t, typename node_t >
     339        resultN< container_t, node_t > call_accept( const container_t< ptr<node_t> > & container );
    259340
    260341public:
    261342        /// Logic to call the accept and mutate the parent if needed, delegates call to accept
    262         template<typename node_t, typename parent_t, typename child_t>
    263         void maybe_accept(const node_t * &, child_t parent_t::* child);
    264 
    265         template<typename node_t, typename parent_t, typename child_t>
    266         void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
     343        template<typename node_t, typename parent_t, typename field_t>
     344        void maybe_accept(const node_t * &, field_t parent_t::* field);
     345
     346        template<typename node_t, typename parent_t, typename field_t>
     347        void maybe_accept_as_compound(const node_t * &, field_t parent_t::* field);
    267348
    268349private:

  • src/AST/Pass.impl.hpp

    r97c215f rf5a51db  
    3434        __pass::previsit( core, node, 0 );
    3535
    36 #define VISIT( code... ) \
    37         /* if this node should visit its children */ \
    38         if ( __visit_children() ) { \
    39                 /* visit the children */ \
    40                 code \
    41         }
    42 
    4336#define VISIT_END( type, node ) \
    4437        /* call the implementation of the postvisit of this pass */ \
    … …  
    8679
    8780                template<typename it_t, template <class...> class container_t>
    88                 static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * decls, bool * mutated = nullptr ) {
    89                         if(empty(decls)) return;
    90 
    91                         std::move(decls->begin(), decls->end(), it);
    92                         decls->clear();
     81                static inline void take_all( it_t it, container_t<ast::ptr<ast::Stmt>> * stmts, bool * mutated = nullptr ) {
     82                        if(empty(stmts)) return;
     83
     84                        std::move(stmts->begin(), stmts->end(), it);
     85                        stmts->clear();
    9386                        if(mutated) *mutated = true;
    9487                }
    … …  
    130123                        return !new_val.empty();
    131124                }
     125        }
     126
     127
     128        template< typename core_t >
     129        template< typename node_t >
     130        template< typename object_t, typename super_t, typename field_t >
     131        void ast::Pass< core_t >::result1< node_t >::apply(object_t * object, field_t super_t::* field) {
     132                object->*field = value;
    132133        }
    133134
    … …  
    138139                                !std::is_base_of<ast::Expr, node_t>::value &&
    139140                                !std::is_base_of<ast::Stmt, node_t>::value
    140                         , decltype( node->accept(*this) )
     141                        , ast::Pass< core_t >::result1<
     142                                typename std::remove_pointer< decltype( node->accept(*this) ) >::type
     143                        >
    141144                >::type
    142145        {
    … …  
    147150                static_assert( !std::is_base_of<ast::Stmt, node_t>::value, "ERROR");
    148151
    149                 return node->accept( *this );
     152                auto nval = node->accept( *this );
     153                ast::Pass< core_t >::result1<
     154                        typename std::remove_pointer< decltype( node->accept(*this) ) >::type
     155                > res;
     156                res.differs = nval != node;
     157                res.value = nval;
     158                return res;
    150159        }
    151160
    152161        template< typename core_t >
    153         const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
     162        ast::Pass< core_t >::result1<ast::Expr> ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
    154163                __pedantic_pass_assert( __visit_children() );
    155164                __pedantic_pass_assert( expr );
    … …  
    160169                }
    161170
    162                 return expr->accept( *this );
     171                auto nval = expr->accept( *this );
     172                return { nval != expr, nval };
    163173        }
    164174
    165175        template< typename core_t >
    166         const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
     176        ast::Pass< core_t >::result1<ast::Stmt> ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
    167177                __pedantic_pass_assert( __visit_children() );
    168178                __pedantic_pass_assert( stmt );
    169179
    170                 return stmt->accept( *this );
     180                const ast::Stmt * nval = stmt->accept( *this );
     181                return { nval != stmt, nval };
    171182        }
    172183
    173184        template< typename core_t >
    174         const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
     185        ast::Pass< core_t >::result1<ast::Stmt> ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
    175186                __pedantic_pass_assert( __visit_children() );
    176187                __pedantic_pass_assert( stmt );
    … …  
    197208                // If the pass doesn't want to add anything then we are done
    198209                if( empty(stmts_before) && empty(stmts_after) && empty(decls_before) && empty(decls_after) ) {
    199                         return nstmt;
     210                        return { nstmt != stmt, nstmt };
    200211                }
    201212
    … …  
    219230                __pass::take_all( std::back_inserter( compound->kids ), stmts_after );
    220231
    221                 return compound;
     232                return {true, compound};
    222233        }
    223234
    224235        template< typename core_t >
    225236        template< template <class...> class container_t >
    226         container_t< ptr<Stmt> > ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
     237        template< typename object_t, typename super_t, typename field_t >
     238        void ast::Pass< core_t >::resultNstmt<container_t>::apply(object_t * object, field_t super_t::* field) {
     239                auto & container = object->*field;
     240                __pedantic_pass_assert( container.size() <= values.size() );
     241
     242                auto cit = enumerate(container).begin();
     243
     244                container_t<ptr<Stmt>> nvals;
     245                for(delta & d : values) {
     246                        if( d.is_old ) {
     247                                __pedantic_pass_assert( cit.idx <= d.old_idx );
     248                                std::advance( cit, d.old_idx - cit.idx );
     249                                nvals.push_back( std::move( (*cit).val) );
     250                        } else {
     251                                nvals.push_back( std::move(d.nval) );
     252                        }
     253                }
     254
     255                object->*field = std::move(nvals);
     256        }
     257
     258        template< typename core_t >
     259        template< template <class...> class container_t >
     260        ast::Pass< core_t >::resultNstmt<container_t> ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
    227261                __pedantic_pass_assert( __visit_children() );
    228262                if( statements.empty() ) return {};
    … …  
    251285                pass_visitor_stats.avg->push(pass_visitor_stats.depth);
    252286
    253                 bool mutated = false;
    254                 container_t< ptr<Stmt> > new_kids;
    255                 for( const Stmt * stmt : statements ) {
     287                resultNstmt<container_t> new_kids;
     288                for( auto value : enumerate( statements ) ) {
    256289                        try {
     290                                size_t i = value.idx;
     291                                const Stmt * stmt = value.val;
    257292                                __pedantic_pass_assert( stmt );
    258293                                const ast::Stmt * new_stmt = stmt->accept( *this );
    259294                                assert( new_stmt );
    260                                 if(new_stmt != stmt ) mutated = true;
     295                                if(new_stmt != stmt ) { new_kids.differs = true; }
    261296
    262297                                // Make sure that it is either adding statements or declartions but not both
    … …  
    268303
    269304                                // Take all the statements which should have gone after, N/A for first iteration
    270                                 __pass::take_all( std::back_inserter( new_kids ), decls_before, &mutated );
    271                                 __pass::take_all( std::back_inserter( new_kids ), stmts_before, &mutated );
     305                                new_kids.take_all( decls_before );
     306                                new_kids.take_all( stmts_before );
    272307
    273308                                // Now add the statement if there is one
    274                                 new_kids.emplace_back( new_stmt );
     309                                if(new_stmt != stmt) {
     310                                        new_kids.values.emplace_back( new_stmt, i, false );
     311                                } else {
     312                                        new_kids.values.emplace_back( nullptr, i, true );
     313                                }
    275314
    276315                                // Take all the declarations that go before
    277                                 __pass::take_all( std::back_inserter( new_kids ), decls_after, &mutated );
    278                                 __pass::take_all( std::back_inserter( new_kids ), stmts_after, &mutated );
     316                                new_kids.take_all( decls_after );
     317                                new_kids.take_all( stmts_after );
    279318                        }
    280319                        catch ( SemanticErrorException &e ) {
    … …  
    285324                if ( !errors.isEmpty() ) { throw errors; }
    286325
    287                 return mutated ? new_kids : container_t< ptr<Stmt> >();
     326                return new_kids;
    288327        }
    289328
    290329        template< typename core_t >
    291330        template< template <class...> class container_t, typename node_t >
    292         container_t< ast::ptr<node_t> > ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
     331        template< typename object_t, typename super_t, typename field_t >
     332        void ast::Pass< core_t >::resultN<container_t, node_t>::apply(object_t * object, field_t super_t::* field) {
     333                auto & container = object->*field;
     334                __pedantic_pass_assert( container.size() == values.size() );
     335
     336                for(size_t i = 0; i < container.size(); i++) {
     337                        // Take all the elements that are different in 'values'
     338                        // and swap them into 'container'
     339                        if( values[i] != nullptr ) std::swap(container[i], values[i]);
     340                }
     341
     342                // Now the original containers should still have the unchanged values
     343                // but also contain the new values
     344        }
     345
     346        template< typename core_t >
     347        template< template <class...> class container_t, typename node_t >
     348        ast::Pass< core_t >::resultN<container_t, node_t> ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
    293349                __pedantic_pass_assert( __visit_children() );
    294350                if( container.empty() ) return {};
    … …  
    300356
    301357                bool mutated = false;
    302                 container_t< ast::ptr<node_t> > new_kids;
     358                container_t<ptr<node_t>> new_kids;
    303359                for ( const node_t * node : container ) {
    304360                        try {
    305361                                __pedantic_pass_assert( node );
    306362                                const node_t * new_stmt = strict_dynamic_cast< const node_t * >( node->accept( *this ) );
    307                                 if(new_stmt != node ) mutated = true;
    308 
    309                                 new_kids.emplace_back( new_stmt );
     363                                if(new_stmt != node ) {
     364                                        mutated = true;
     365                                        new_kids.emplace_back( new_stmt );
     366                                } else {
     367                                        new_kids.emplace_back( nullptr );
     368                                }
     369
    310370                        }
    311371                        catch( SemanticErrorException &e ) {
    … …  
    313373                        }
    314374                }
     375
     376                __pedantic_pass_assert( new_kids.size() == container.size() );
    315377                pass_visitor_stats.depth--;
    316378                if ( ! errors.isEmpty() ) { throw errors; }
    317379
    318                 return mutated ? new_kids : container_t< ast::ptr<node_t> >();
     380                return ast::Pass< core_t >::resultN<container_t, node_t>{ mutated,  new_kids };
    319381        }
    320382
    … …  
    334396                auto new_val = call_accept( old_val );
    335397
    336                 static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
    337 
    338                 if( __pass::differs(old_val, new_val) ) {
     398                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value /* || std::is_same<int, decltype(old_val)>::value */, "ERROR");
     399
     400                if( new_val.differs ) {
    339401                        auto new_parent = __pass::mutate<core_t>(parent);
    340                         new_parent->*child = new_val;
     402                        new_val.apply(new_parent, child);
    341403                        parent = new_parent;
    342404                }
    … …  
    360422                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
    361423
    362                 if( __pass::differs(old_val, new_val) ) {
     424                if( new_val.differs ) {
    363425                        auto new_parent = __pass::mutate<core_t>(parent);
    364                         new_parent->*child = new_val;
     426                        new_val.apply( new_parent, child );
    365427                        parent = new_parent;
    366428                }
    … …  
    452514        VISIT_START( node );
    453515
    454         VISIT(
     516        if ( __visit_children() ) {
    455517                {
    456518                        guard_symtab guard { *this };
    … …  
    460522                maybe_accept( node, &ObjectDecl::bitfieldWidth );
    461523                maybe_accept( node, &ObjectDecl::attributes    );
    462         )
     524        }
    463525
    464526        __pass::symtab::addId( core, 0, node );
    … …  
    475537        __pass::symtab::addId( core, 0, node );
    476538
    477         VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
     539        if ( __visit_children() ) {
     540                maybe_accept( node, &FunctionDecl::withExprs );
     541        }
    478542        {
    479543                // with clause introduces a level of scope (for the with expression members).
    … …  
    493557                        } };
    494558                        __pass::symtab::addId( core, 0, func );
    495                         VISIT(
     559                        if ( __visit_children() ) {
    496560                                // parameter declarations
    497561                                maybe_accept( node, &FunctionDecl::params );
    … …  
    509573                                maybe_accept( node, &FunctionDecl::stmts );
    510574                                maybe_accept( node, &FunctionDecl::attributes );
    511                         )
     575                        }
    512576                }
    513577        }
    … …  
    526590        __pass::symtab::addStructFwd( core, 0, node );
    527591
    528         VISIT({
     592        if ( __visit_children() ) {
    529593                guard_symtab guard { * this };
    530594                maybe_accept( node, &StructDecl::params     );
    531595                maybe_accept( node, &StructDecl::members    );
    532596                maybe_accept( node, &StructDecl::attributes );
    533         })
     597        }
    534598
    535599        // this addition replaces the forward declaration
    … …  
    548612        __pass::symtab::addUnionFwd( core, 0, node );
    549613
    550         VISIT({
     614        if ( __visit_children() ) {
    551615                guard_symtab guard { * this };
    552616                maybe_accept( node, &UnionDecl::params     );
    553617                maybe_accept( node, &UnionDecl::members    );
    554618                maybe_accept( node, &UnionDecl::attributes );
    555         })
     619        }
    556620
    557621        __pass::symtab::addUnion( core, 0, node );
    … …  
    568632        __pass::symtab::addEnum( core, 0, node );
    569633
    570         VISIT(
     634        if ( __visit_children() ) {
    571635                // unlike structs, traits, and unions, enums inject their members into the global scope
    572636                maybe_accept( node, &EnumDecl::params     );
    573637                maybe_accept( node, &EnumDecl::members    );
    574638                maybe_accept( node, &EnumDecl::attributes );
    575         )
     639        }
    576640
    577641        VISIT_END( Decl, node );
    … …  
    584648        VISIT_START( node );
    585649
    586         VISIT({
     650        if ( __visit_children() ) {
    587651                guard_symtab guard { *this };
    588652                maybe_accept( node, &TraitDecl::params     );
    589653                maybe_accept( node, &TraitDecl::members    );
    590654                maybe_accept( node, &TraitDecl::attributes );
    591         })
     655        }
    592656
    593657        __pass::symtab::addTrait( core, 0, node );
    … …  
    602666        VISIT_START( node );
    603667
    604         VISIT({
     668        if ( __visit_children() ) {
    605669                guard_symtab guard { *this };
    606670                maybe_accept( node, &TypeDecl::base   );
    607         })
     671        }
    608672
    609673        // see A NOTE ON THE ORDER OF TRAVERSAL, above
    … …  
    612676        __pass::symtab::addType( core, 0, node );
    613677
    614         VISIT(
     678        if ( __visit_children() ) {
    615679                maybe_accept( node, &TypeDecl::assertions );
    616680
    … …  
    619683                        maybe_accept( node, &TypeDecl::init );
    620684                }
    621         )
     685        }
    622686
    623687        VISIT_END( Decl, node );
    … …  
    630694        VISIT_START( node );
    631695
    632         VISIT({
     696        if ( __visit_children() ) {
    633697                guard_symtab guard { *this };
    634698                maybe_accept( node, &TypedefDecl::base   );
    635         })
     699        }
    636700
    637701        __pass::symtab::addType( core, 0, node );
    638702
    639         VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
     703        if ( __visit_children() ) {
     704                maybe_accept( node, &TypedefDecl::assertions );
     705        }
    640706
    641707        VISIT_END( Decl, node );
    … …  
    648714        VISIT_START( node );
    649715
    650         VISIT(
     716        if ( __visit_children() ) {
    651717                maybe_accept( node, &AsmDecl::stmt );
    652         )
     718        }
    653719
    654720        VISIT_END( AsmDecl, node );
    … …  
    661727        VISIT_START( node );
    662728
    663         VISIT(
     729        if ( __visit_children() ) {
    664730                maybe_accept( node, &DirectiveDecl::stmt );
    665         )
     731        }
    666732
    667733        VISIT_END( DirectiveDecl, node );
    … …  
    674740        VISIT_START( node );
    675741
    676         VISIT(
     742        if ( __visit_children() ) {
    677743                maybe_accept( node, &StaticAssertDecl::cond );
    678744                maybe_accept( node, &StaticAssertDecl::msg  );
    679         )
     745        }
    680746
    681747        VISIT_END( StaticAssertDecl, node );
    … …  
    687753const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
    688754        VISIT_START( node );
    689         VISIT(
     755
     756        if ( __visit_children() ) {
    690757                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
    691758                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
    … …  
    704771                guard_scope guard3 { *this };
    705772                maybe_accept( node, &CompoundStmt::kids );
    706         )
     773        }
     774
    707775        VISIT_END( CompoundStmt, node );
    708776}
    … …  
    714782        VISIT_START( node );
    715783
    716         VISIT(
     784        if ( __visit_children() ) {
    717785                maybe_accept( node, &ExprStmt::expr );
    718         )
     786        }
    719787
    720788        VISIT_END( Stmt, node );
    … …  
    727795        VISIT_START( node )
    728796
    729         VISIT(
     797        if ( __visit_children() ) {
    730798                maybe_accept( node, &AsmStmt::instruction );
    731799                maybe_accept( node, &AsmStmt::output      );
    732800                maybe_accept( node, &AsmStmt::input       );
    733801                maybe_accept( node, &AsmStmt::clobber     );
    734         )
     802        }
    735803
    736804        VISIT_END( Stmt, node );
    … …  
    752820        VISIT_START( node );
    753821
    754         VISIT({
     822        if ( __visit_children() ) {
    755823                // if statements introduce a level of scope (for the initialization)
    756824                guard_symtab guard { *this };
    757825                maybe_accept( node, &IfStmt::inits    );
    758826                maybe_accept( node, &IfStmt::cond     );
    759                 maybe_accept_as_compound( node, &IfStmt::thenPart );
    760                 maybe_accept_as_compound( node, &IfStmt::elsePart );
    761         })
     827                maybe_accept_as_compound( node, &IfStmt::then );
     828                maybe_accept_as_compound( node, &IfStmt::else_ );
     829        }
    762830
    763831        VISIT_END( Stmt, node );
    … …  
    765833
    766834//--------------------------------------------------------------------------
    767 // WhileStmt
    768 template< typename core_t >
    769 const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
    770         VISIT_START( node );
    771 
    772         VISIT({
     835// WhileDoStmt
     836template< typename core_t >
     837const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileDoStmt * node ) {
     838        VISIT_START( node );
     839
     840        if ( __visit_children() ) {
    773841                // while statements introduce a level of scope (for the initialization)
    774842                guard_symtab guard { *this };
    775                 maybe_accept( node, &WhileStmt::inits );
    776                 maybe_accept( node, &WhileStmt::cond  );
    777                 maybe_accept_as_compound( node, &WhileStmt::body  );
    778         })
     843                maybe_accept( node, &WhileDoStmt::inits );
     844                maybe_accept( node, &WhileDoStmt::cond  );
     845                maybe_accept_as_compound( node, &WhileDoStmt::body  );
     846        }
    779847
    780848        VISIT_END( Stmt, node );
    … …  
    787855        VISIT_START( node );
    788856
    789         VISIT({
     857        if ( __visit_children() ) {
    790858                // for statements introduce a level of scope (for the initialization)
    791859                guard_symtab guard { *this };
    … …  
    795863                maybe_accept( node, &ForStmt::inc   );
    796864                maybe_accept_as_compound( node, &ForStmt::body  );
    797         })
     865        }
    798866
    799867        VISIT_END( Stmt, node );
    … …  
    806874        VISIT_START( node );
    807875
    808         VISIT(
     876        if ( __visit_children() ) {
    809877                maybe_accept( node, &SwitchStmt::cond  );
    810878                maybe_accept( node, &SwitchStmt::stmts );
    811         )
     879        }
    812880
    813881        VISIT_END( Stmt, node );
    … …  
    820888        VISIT_START( node );
    821889
    822         VISIT(
     890        if ( __visit_children() ) {
    823891                maybe_accept( node, &CaseStmt::cond  );
    824892                maybe_accept( node, &CaseStmt::stmts );
    825         )
     893        }
    826894
    827895        VISIT_END( Stmt, node );
    … …  
    842910        VISIT_START( node );
    843911
    844         VISIT(
     912        if ( __visit_children() ) {
    845913                maybe_accept( node, &ReturnStmt::expr );
    846         )
     914        }
    847915
    848916        VISIT_END( Stmt, node );
    … …  
    855923        VISIT_START( node );
    856924
    857         VISIT(
     925        if ( __visit_children() ) {
    858926                maybe_accept( node, &ThrowStmt::expr   );
    859927                maybe_accept( node, &ThrowStmt::target );
    860         )
     928        }
    861929
    862930        VISIT_END( Stmt, node );
    … …  
    869937        VISIT_START( node );
    870938
    871         VISIT(
     939        if ( __visit_children() ) {
    872940                maybe_accept( node, &TryStmt::body     );
    873941                maybe_accept( node, &TryStmt::handlers );
    874942                maybe_accept( node, &TryStmt::finally  );
    875         )
     943        }
    876944
    877945        VISIT_END( Stmt, node );
    … …  
    884952        VISIT_START( node );
    885953
    886         VISIT({
     954        if ( __visit_children() ) {
    887955                // catch statements introduce a level of scope (for the caught exception)
    888956                guard_symtab guard { *this };
    … …  
    890958                maybe_accept( node, &CatchStmt::cond );
    891959                maybe_accept_as_compound( node, &CatchStmt::body );
    892         })
     960        }
    893961
    894962        VISIT_END( Stmt, node );
    … …  
    901969        VISIT_START( node );
    902970
    903         VISIT(
     971        if ( __visit_children() ) {
    904972                maybe_accept( node, &FinallyStmt::body );
    905         )
     973        }
    906974
    907975        VISIT_END( Stmt, node );
    … …  
    914982        VISIT_START( node );
    915983
    916         VISIT(
     984        if ( __visit_children() ) {
    917985                maybe_accept( node, &SuspendStmt::then   );
    918         )
     986        }
    919987
    920988        VISIT_END( Stmt, node );
    … …  
    9341002                // }
    9351003
    936         VISIT({
     1004        if ( __visit_children() ) {
    9371005                std::vector<WaitForStmt::Clause> new_clauses;
    9381006                new_clauses.reserve( node->clauses.size() );
    … …  
    9421010                        const Expr * func = clause.target.func ? clause.target.func->accept(*this) : nullptr;
    9431011                        if(func != clause.target.func) mutated = true;
     1012                        else func = nullptr;
    9441013
    9451014                        std::vector<ptr<Expr>> new_args;
    … …  
    9471016                        for( const auto & arg : clause.target.args ) {
    9481017                                auto a = arg->accept(*this);
    949                                 new_args.push_back( a );
    950                                 if( a != arg ) mutated = true;
     1018                                if( a != arg ) {
     1019                                        mutated = true;
     1020                                        new_args.push_back( a );
     1021                                } else
     1022                                        new_args.push_back( nullptr );
    9511023                        }
    9521024
    9531025                        const Stmt * stmt = clause.stmt ? clause.stmt->accept(*this) : nullptr;
    9541026                        if(stmt != clause.stmt) mutated = true;
     1027                        else stmt = nullptr;
    9551028
    9561029                        const Expr * cond = clause.cond ? clause.cond->accept(*this) : nullptr;
    9571030                        if(cond != clause.cond) mutated = true;
     1031                        else cond = nullptr;
    9581032
    9591033                        new_clauses.push_back( WaitForStmt::Clause{ {func, std::move(new_args) }, stmt, cond } );
    … …  
    9621036                if(mutated) {
    9631037                        auto n = __pass::mutate<core_t>(node);
    964                         n->clauses = std::move( new_clauses );
     1038                        for(size_t i = 0; i < new_clauses.size(); i++) {
     1039                                if(new_clauses.at(i).target.func != nullptr) std::swap(n->clauses.at(i).target.func, new_clauses.at(i).target.func);
     1040
     1041                                for(size_t j = 0; j < new_clauses.at(i).target.args.size(); j++) {
     1042                                        if(new_clauses.at(i).target.args.at(j) != nullptr) std::swap(n->clauses.at(i).target.args.at(j), new_clauses.at(i).target.args.at(j));
     1043                                }
     1044
     1045                                if(new_clauses.at(i).stmt != nullptr) std::swap(n->clauses.at(i).stmt, new_clauses.at(i).stmt);
     1046                                if(new_clauses.at(i).cond != nullptr) std::swap(n->clauses.at(i).cond, new_clauses.at(i).cond);
     1047                        }
    9651048                        node = n;
    9661049                }
    967         })
     1050        }
    9681051
    9691052        #define maybe_accept(field) \
    9701053                if(node->field) { \
    9711054                        auto nval = call_accept( node->field ); \
    972                         if(nval != node->field ) { \
     1055                        if(nval.differs ) { \
    9731056                                auto nparent = __pass::mutate<core_t>(node); \
    974                                 nparent->field = nval; \
     1057                                nparent->field = nval.value; \
    9751058                                node = nparent; \
    9761059                        } \
    9771060                }
    9781061
    979         VISIT(
     1062        if ( __visit_children() ) {
    9801063                maybe_accept( timeout.time );
    9811064                maybe_accept( timeout.stmt );
    … …  
    9831066                maybe_accept( orElse.stmt  );
    9841067                maybe_accept( orElse.cond  );
    985         )
     1068        }
    9861069
    9871070        #undef maybe_accept
    … …  
    9961079        VISIT_START( node );
    9971080
    998         VISIT(
     1081        if ( __visit_children() ) {
    9991082                maybe_accept( node, &WithStmt::exprs );
    10001083                {
    … …  
    10041087                        maybe_accept( node, &WithStmt::stmt );
    10051088                }
    1006         )
     1089        }
     1090
    10071091        VISIT_END( Stmt, node );
    10081092}
    … …  
    10221106        VISIT_START( node );
    10231107
    1024         VISIT(
     1108        if ( __visit_children() ) {
    10251109                maybe_accept( node, &DeclStmt::decl );
    1026         )
     1110        }
    10271111
    10281112        VISIT_END( Stmt, node );
    … …  
    10371121        // For now this isn't visited, it is unclear if this causes problem
    10381122        // if all tests are known to pass, remove this code
    1039         VISIT(
     1123        if ( __visit_children() ) {
    10401124                maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
    1041         )
     1125        }
    10421126
    10431127        VISIT_END( Stmt, node );
    … …  
    10501134        VISIT_START( node );
    10511135
    1052         VISIT({
     1136        if ( __visit_children() ) {
    10531137                // mutex statements introduce a level of scope (for the initialization)
    10541138                guard_symtab guard { *this };
    10551139                maybe_accept( node, &MutexStmt::stmt );
    10561140                maybe_accept( node, &MutexStmt::mutexObjs );
    1057         })
     1141        }
    10581142
    10591143        VISIT_END( Stmt, node );
    … …  
    10661150        VISIT_START( node );
    10671151
    1068         VISIT(
     1152        if ( __visit_children() ) {
    10691153                {
    10701154                        guard_symtab guard { *this };
    … …  
    10731157                maybe_accept( node, &ApplicationExpr::func );
    10741158                maybe_accept( node, &ApplicationExpr::args );
    1075         )
     1159        }
    10761160
    10771161        VISIT_END( Expr, node );
    … …  
    10841168        VISIT_START( node );
    10851169
    1086         VISIT(
     1170        if ( __visit_children() ) {
    10871171                {
    10881172                        guard_symtab guard { *this };
    … …  
    10911175
    10921176                maybe_accept( node, &UntypedExpr::args );
    1093         )
     1177        }
    10941178
    10951179        VISIT_END( Expr, node );
    … …  
    11021186        VISIT_START( node );
    11031187
    1104         VISIT({
     1188        if ( __visit_children() ) {
    11051189                guard_symtab guard { *this };
    11061190                maybe_accept( node, &NameExpr::result );
    1107         })
     1191        }
    11081192
    11091193        VISIT_END( Expr, node );
    … …  
    11161200        VISIT_START( node );
    11171201
    1118         VISIT({
     1202        if ( __visit_children() ) {
     1203                {
    11191204                        guard_symtab guard { *this };
    11201205                        maybe_accept( node, &CastExpr::result );
    11211206                }
    11221207                maybe_accept( node, &CastExpr::arg );
    1123         )
     1208        }
    11241209
    11251210        VISIT_END( Expr, node );
    … …  
    11321217        VISIT_START( node );
    11331218
    1134         VISIT({
     1219        if ( __visit_children() ) {
     1220                {
    11351221                        guard_symtab guard { *this };
    11361222                        maybe_accept( node, &KeywordCastExpr::result );
    11371223                }
    11381224                maybe_accept( node, &KeywordCastExpr::arg );
    1139         )
     1225        }
    11401226
    11411227        VISIT_END( Expr, node );
    … …  
    11481234        VISIT_START( node );
    11491235
    1150         VISIT({
     1236        if ( __visit_children() ) {
     1237                {
    11511238                        guard_symtab guard { *this };
    11521239                        maybe_accept( node, &VirtualCastExpr::result );
    11531240                }
    11541241                maybe_accept( node, &VirtualCastExpr::arg );
    1155         )
     1242        }
    11561243
    11571244        VISIT_END( Expr, node );
    … …  
    11641251        VISIT_START( node );
    11651252
    1166         VISIT({
     1253        if ( __visit_children() ) {
     1254                {
    11671255                        guard_symtab guard { *this };
    11681256                        maybe_accept( node, &AddressExpr::result );
    11691257                }
    11701258                maybe_accept( node, &AddressExpr::arg );
    1171         )
     1259        }
    11721260
    11731261        VISIT_END( Expr, node );
    … …  
    11801268        VISIT_START( node );
    11811269
    1182         VISIT({
     1270        if ( __visit_children() ) {
    11831271                guard_symtab guard { *this };
    11841272                maybe_accept( node, &LabelAddressExpr::result );
    1185         })
     1273        }
    11861274
    11871275        VISIT_END( Expr, node );
    … …  
    11941282        VISIT_START( node );
    11951283
    1196         VISIT({
     1284        if ( __visit_children() ) {
     1285                {
    11971286                        guard_symtab guard { *this };
    11981287                        maybe_accept( node, &UntypedMemberExpr::result );
    … …  
    12001289                maybe_accept( node, &UntypedMemberExpr::aggregate );
    12011290                maybe_accept( node, &UntypedMemberExpr::member    );
    1202         )
     1291        }
    12031292
    12041293        VISIT_END( Expr, node );
    … …  
    12111300        VISIT_START( node );
    12121301
    1213         VISIT({
     1302        if ( __visit_children() ) {
     1303                {
    12141304                        guard_symtab guard { *this };
    12151305                        maybe_accept( node, &MemberExpr::result );
    12161306                }
    12171307                maybe_accept( node, &MemberExpr::aggregate );
    1218         )
     1308        }
    12191309
    12201310        VISIT_END( Expr, node );
    … …  
    12271317        VISIT_START( node );
    12281318
    1229         VISIT({
     1319        if ( __visit_children() ) {
    12301320                guard_symtab guard { *this };
    12311321                maybe_accept( node, &VariableExpr::result );
    1232         })
     1322        }
    12331323
    12341324        VISIT_END( Expr, node );
    … …  
    12411331        VISIT_START( node );
    12421332
    1243         VISIT({
     1333        if ( __visit_children() ) {
    12441334                guard_symtab guard { *this };
    12451335                maybe_accept( node, &ConstantExpr::result );
    1246         })
     1336        }
    12471337
    12481338        VISIT_END( Expr, node );
    … …  
    12551345        VISIT_START( node );
    12561346
    1257         VISIT({
     1347        if ( __visit_children() ) {
     1348                {
    12581349                        guard_symtab guard { *this };
    12591350                        maybe_accept( node, &SizeofExpr::result );
    … …  
    12641355                        maybe_accept( node, &SizeofExpr::expr );
    12651356                }
    1266         )
     1357        }
    12671358
    12681359        VISIT_END( Expr, node );
    … …  
    12751366        VISIT_START( node );
    12761367
    1277         VISIT({
     1368        if ( __visit_children() ) {
     1369                {
    12781370                        guard_symtab guard { *this };
    12791371                        maybe_accept( node, &AlignofExpr::result );
    … …  
    12841376                        maybe_accept( node, &AlignofExpr::expr );
    12851377                }
    1286         )
     1378        }
    12871379
    12881380        VISIT_END( Expr, node );
    … …  
    12951387        VISIT_START( node );
    12961388
    1297         VISIT({
     1389        if ( __visit_children() ) {
     1390                {
    12981391                        guard_symtab guard { *this };
    12991392                        maybe_accept( node, &UntypedOffsetofExpr::result );
    13001393                }
    13011394                maybe_accept( node, &UntypedOffsetofExpr::type   );
    1302         )
     1395        }
    13031396
    13041397        VISIT_END( Expr, node );
    … …  
    13111404        VISIT_START( node );
    13121405
    1313         VISIT({
     1406        if ( __visit_children() ) {
     1407                {
    13141408                        guard_symtab guard { *this };
    13151409                        maybe_accept( node, &OffsetofExpr::result );
    13161410                }
    13171411                maybe_accept( node, &OffsetofExpr::type   );
    1318         )
     1412        }
    13191413
    13201414        VISIT_END( Expr, node );
    … …  
    13271421        VISIT_START( node );
    13281422
    1329         VISIT({
     1423        if ( __visit_children() ) {
     1424                {
    13301425                        guard_symtab guard { *this };
    13311426                        maybe_accept( node, &OffsetPackExpr::result );
    13321427                }
    13331428                maybe_accept( node, &OffsetPackExpr::type   );
    1334         )
     1429        }
    13351430
    13361431        VISIT_END( Expr, node );
    … …  
    13431438        VISIT_START( node );
    13441439
    1345         VISIT({
     1440        if ( __visit_children() ) {
     1441                {
    13461442                        guard_symtab guard { *this };
    13471443                        maybe_accept( node, &LogicalExpr::result );
    … …  
    13491445                maybe_accept( node, &LogicalExpr::arg1 );
    13501446                maybe_accept( node, &LogicalExpr::arg2 );
    1351         )
     1447        }
    13521448
    13531449        VISIT_END( Expr, node );
    … …  
    13601456        VISIT_START( node );
    13611457
    1362         VISIT({
     1458        if ( __visit_children() ) {
     1459                {
    13631460                        guard_symtab guard { *this };
    13641461                        maybe_accept( node, &ConditionalExpr::result );
    … …  
    13671464                maybe_accept( node, &ConditionalExpr::arg2 );
    13681465                maybe_accept( node, &ConditionalExpr::arg3 );
    1369         )
     1466        }
    13701467
    13711468        VISIT_END( Expr, node );
    … …  
    13781475        VISIT_START( node );
    13791476
    1380         VISIT({
     1477        if ( __visit_children() ) {
     1478                {
    13811479                        guard_symtab guard { *this };
    13821480                        maybe_accept( node, &CommaExpr::result );
    … …  
    13841482                maybe_accept( node, &CommaExpr::arg1 );
    13851483                maybe_accept( node, &CommaExpr::arg2 );
    1386         )
     1484        }
    13871485
    13881486        VISIT_END( Expr, node );
    … …  
    13951493        VISIT_START( node );
    13961494
    1397         VISIT({
     1495        if ( __visit_children() ) {
     1496                {
    13981497                        guard_symtab guard { *this };
    13991498                        maybe_accept( node, &TypeExpr::result );
    14001499                }
    14011500                maybe_accept( node, &TypeExpr::type );
    1402         )
     1501        }
    14031502
    14041503        VISIT_END( Expr, node );
    … …  
    14111510        VISIT_START( node );
    14121511
    1413         VISIT({
     1512        if ( __visit_children() ) {
     1513                {
    14141514                        guard_symtab guard { *this };
    14151515                        maybe_accept( node, &AsmExpr::result );
    … …  
    14171517                maybe_accept( node, &AsmExpr::constraint );
    14181518                maybe_accept( node, &AsmExpr::operand    );
    1419         )
     1519        }
    14201520
    14211521        VISIT_END( Expr, node );
    … …  
    14281528        VISIT_START( node );
    14291529
    1430         VISIT({
     1530        if ( __visit_children() ) {
     1531                {
    14311532                        guard_symtab guard { *this };
    14321533                        maybe_accept( node, &ImplicitCopyCtorExpr::result );
    14331534                }
    14341535                maybe_accept( node, &ImplicitCopyCtorExpr::callExpr    );
    1435         )
     1536        }
    14361537
    14371538        VISIT_END( Expr, node );
    … …  
    14441545        VISIT_START( node );
    14451546
    1446         VISIT({
     1547        if ( __visit_children() ) {
     1548                {
    14471549                        guard_symtab guard { *this };
    14481550                        maybe_accept( node, &ConstructorExpr::result );
    14491551                }
    14501552                maybe_accept( node, &ConstructorExpr::callExpr );
    1451         )
     1553        }
    14521554
    14531555        VISIT_END( Expr, node );
    … …  
    14601562        VISIT_START( node );
    14611563
    1462         VISIT({
     1564        if ( __visit_children() ) {
     1565                {
    14631566                        guard_symtab guard { *this };
    14641567                        maybe_accept( node, &CompoundLiteralExpr::result );
    14651568                }
    14661569                maybe_accept( node, &CompoundLiteralExpr::init );
    1467         )
     1570        }
    14681571
    14691572        VISIT_END( Expr, node );
    … …  
    14761579        VISIT_START( node );
    14771580
    1478         VISIT({
     1581        if ( __visit_children() ) {
     1582                {
    14791583                        guard_symtab guard { *this };
    14801584                        maybe_accept( node, &RangeExpr::result );
    … …  
    14821586                maybe_accept( node, &RangeExpr::low    );
    14831587                maybe_accept( node, &RangeExpr::high   );
    1484         )
     1588        }
    14851589
    14861590        VISIT_END( Expr, node );
    … …  
    14931597        VISIT_START( node );
    14941598
    1495         VISIT({
     1599        if ( __visit_children() ) {
     1600                {
    14961601                        guard_symtab guard { *this };
    14971602                        maybe_accept( node, &UntypedTupleExpr::result );
    14981603                }
    14991604                maybe_accept( node, &UntypedTupleExpr::exprs  );
    1500         )
     1605        }
    15011606
    15021607        VISIT_END( Expr, node );
    … …  
    15091614        VISIT_START( node );
    15101615
    1511         VISIT({
     1616        if ( __visit_children() ) {
     1617                {
    15121618                        guard_symtab guard { *this };
    15131619                        maybe_accept( node, &TupleExpr::result );
    15141620                }
    15151621                maybe_accept( node, &TupleExpr::exprs  );
    1516         )
     1622        }
    15171623
    15181624        VISIT_END( Expr, node );
    … …  
    15251631        VISIT_START( node );
    15261632
    1527         VISIT({
     1633        if ( __visit_children() ) {
     1634                {
    15281635                        guard_symtab guard { *this };
    15291636                        maybe_accept( node, &TupleIndexExpr::result );
    15301637                }
    15311638                maybe_accept( node, &TupleIndexExpr::tuple  );
    1532         )
     1639        }
    15331640
    15341641        VISIT_END( Expr, node );
    … …  
    15411648        VISIT_START( node );
    15421649
    1543         VISIT({
     1650        if ( __visit_children() ) {
     1651                {
    15441652                        guard_symtab guard { *this };
    15451653                        maybe_accept( node, &TupleAssignExpr::result );
    15461654                }
    15471655                maybe_accept( node, &TupleAssignExpr::stmtExpr );
    1548         )
     1656        }
    15491657
    15501658        VISIT_END( Expr, node );
    … …  
    15571665        VISIT_START( node );
    15581666
    1559         VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
     1667        if ( __visit_children() ) {
     1668                // don't want statements from outer CompoundStmts to be added to this StmtExpr
    15601669                // get the stmts that will need to be spliced in
    15611670                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
    … …  
    15741683                maybe_accept( node, &StmtExpr::returnDecls );
    15751684                maybe_accept( node, &StmtExpr::dtors       );
    1576         )
     1685        }
    15771686
    15781687        VISIT_END( Expr, node );
    … …  
    15851694        VISIT_START( node );
    15861695
    1587         VISIT({
     1696        if ( __visit_children() ) {
     1697                {
    15881698                        guard_symtab guard { *this };
    15891699                        maybe_accept( node, &UniqueExpr::result );
    15901700                }
    15911701                maybe_accept( node, &UniqueExpr::expr   );
    1592         )
     1702        }
    15931703
    15941704        VISIT_END( Expr, node );
    … …  
    16011711        VISIT_START( node );
    16021712
    1603         VISIT({
     1713        if ( __visit_children() ) {
     1714                {
    16041715                        guard_symtab guard { *this };
    16051716                        maybe_accept( node, &UntypedInitExpr::result );
    … …  
    16071718                maybe_accept( node, &UntypedInitExpr::expr   );
    16081719                // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
    1609         )
     1720        }
    16101721
    16111722        VISIT_END( Expr, node );
    … …  
    16181729        VISIT_START( node );
    16191730
    1620         VISIT({
     1731        if ( __visit_children() ) {
     1732                {
    16211733                        guard_symtab guard { *this };
    16221734                        maybe_accept( node, &InitExpr::result );
    … …  
    16241736                maybe_accept( node, &InitExpr::expr   );
    16251737                maybe_accept( node, &InitExpr::designation );
    1626         )
     1738        }
    16271739
    16281740        VISIT_END( Expr, node );
    … …  
    16351747        VISIT_START( node );
    16361748
    1637         VISIT({
     1749        if ( __visit_children() ) {
     1750                {
    16381751                        guard_symtab guard { *this };
    16391752                        maybe_accept( node, &DeletedExpr::result );
    … …  
    16411754                maybe_accept( node, &DeletedExpr::expr );
    16421755                // don't visit deleteStmt, because it is a pointer to somewhere else in the tree.
    1643         )
     1756        }
    16441757
    16451758        VISIT_END( Expr, node );
    … …  
    16521765        VISIT_START( node );
    16531766
    1654         VISIT({
     1767        if ( __visit_children() ) {
     1768                {
    16551769                        guard_symtab guard { *this };
    16561770                        maybe_accept( node, &DefaultArgExpr::result );
    16571771                }
    16581772                maybe_accept( node, &DefaultArgExpr::expr );
    1659         )
     1773        }
    16601774
    16611775        VISIT_END( Expr, node );
    … …  
    16681782        VISIT_START( node );
    16691783
    1670         VISIT({
     1784        if ( __visit_children() ) {
     1785                {
    16711786                        guard_symtab guard { *this };
    16721787                        maybe_accept( node, &GenericExpr::result );
    … …  
    16971812                        node = n;
    16981813                }
    1699         )
     1814        }
    17001815
    17011816        VISIT_END( Expr, node );
    … …  
    17261841        VISIT_START( node );
    17271842
    1728         VISIT(
     1843        if ( __visit_children() ) {
    17291844                // xxx - should PointerType visit/mutate dimension?
    17301845                maybe_accept( node, &PointerType::base );
    1731         )
     1846        }
    17321847
    17331848        VISIT_END( Type, node );
    … …  
    17401855        VISIT_START( node );
    17411856
    1742         VISIT(
     1857        if ( __visit_children() ) {
    17431858                maybe_accept( node, &ArrayType::dimension );
    17441859                maybe_accept( node, &ArrayType::base );
    1745         )
     1860        }
    17461861
    17471862        VISIT_END( Type, node );
    … …  
    17541869        VISIT_START( node );
    17551870
    1756         VISIT(
     1871        if ( __visit_children() ) {
    17571872                maybe_accept( node, &ReferenceType::base );
    1758         )
     1873        }
    17591874
    17601875        VISIT_END( Type, node );
    … …  
    17671882        VISIT_START( node );
    17681883
    1769         VISIT(
     1884        if ( __visit_children() ) {
    17701885                maybe_accept( node, &QualifiedType::parent );
    17711886                maybe_accept( node, &QualifiedType::child );
    1772         )
     1887        }
    17731888
    17741889        VISIT_END( Type, node );
    … …  
    17811896        VISIT_START( node );
    17821897
    1783         VISIT({
     1898        if ( __visit_children() ) {
    17841899                // guard_forall_subs forall_guard { *this, node };
    17851900                // mutate_forall( node );
    … …  
    17871902                maybe_accept( node, &FunctionType::returns );
    17881903                maybe_accept( node, &FunctionType::params  );
    1789         })
     1904        }
    17901905
    17911906        VISIT_END( Type, node );
    … …  
    18001915        __pass::symtab::addStruct( core, 0, node->name );
    18011916
    1802         VISIT({
     1917        if ( __visit_children() ) {
    18031918                guard_symtab guard { *this };
    18041919                maybe_accept( node, &StructInstType::params );
    1805         })
     1920        }
    18061921
    18071922        VISIT_END( Type, node );
    … …  
    18161931        __pass::symtab::addUnion( core, 0, node->name );
    18171932
    1818         VISIT({
     1933        if ( __visit_children() ) {
    18191934                guard_symtab guard { *this };
    18201935                maybe_accept( node, &UnionInstType::params );
    1821         })
     1936        }
    18221937
    18231938        VISIT_END( Type, node );
    … …  
    18301945        VISIT_START( node );
    18311946
    1832         VISIT({
     1947        if ( __visit_children() ) {
    18331948                maybe_accept( node, &EnumInstType::params );
    1834         })
     1949        }
    18351950
    18361951        VISIT_END( Type, node );
    … …  
    18431958        VISIT_START( node );
    18441959
    1845         VISIT({
     1960        if ( __visit_children() ) {
    18461961                maybe_accept( node, &TraitInstType::params );
    1847         })
     1962        }
    18481963
    18491964        VISIT_END( Type, node );
    … …  
    18561971        VISIT_START( node );
    18571972
    1858         VISIT(
     1973        if ( __visit_children() ) {
    18591974                {
    18601975                        maybe_accept( node, &TypeInstType::params );
    … …  
    18621977                // ensure that base re-bound if doing substitution
    18631978                __pass::forall::replace( core, 0, node );
    1864         )
     1979        }
    18651980
    18661981        VISIT_END( Type, node );
    … …  
    18731988        VISIT_START( node );
    18741989
    1875         VISIT(
     1990        if ( __visit_children() ) {
    18761991                maybe_accept( node, &TupleType::types );
    18771992                maybe_accept( node, &TupleType::members );
    1878         )
     1993        }
    18791994
    18801995        VISIT_END( Type, node );
    … …  
    18872002        VISIT_START( node );
    18882003
    1889         VISIT(
     2004        if ( __visit_children() ) {
    18902005                maybe_accept( node, &TypeofType::expr );
    1891         )
     2006        }
    18922007
    18932008        VISIT_END( Type, node );
    … …  
    19002015        VISIT_START( node );
    19012016
    1902         VISIT(
     2017        if ( __visit_children() ) {
    19032018                maybe_accept( node, &VTableType::base );
    1904         )
     2019        }
    19052020
    19062021        VISIT_END( Type, node );
    … …  
    19502065        VISIT_START( node );
    19512066
    1952         VISIT( maybe_accept( node, &Designation::designators ); )
     2067        if ( __visit_children() ) {
     2068                maybe_accept( node, &Designation::designators );
     2069        }
    19532070
    19542071        VISIT_END( Designation, node );
    … …  
    19612078        VISIT_START( node );
    19622079
    1963         VISIT(
     2080        if ( __visit_children() ) {
    19642081                maybe_accept( node, &SingleInit::value );
    1965         )
     2082        }
    19662083
    19672084        VISIT_END( Init, node );
    … …  
    19742091        VISIT_START( node );
    19752092
    1976         VISIT(
     2093        if ( __visit_children() ) {
    19772094                maybe_accept( node, &ListInit::designations );
    19782095                maybe_accept( node, &ListInit::initializers );
    1979         )
     2096        }
    19802097
    19812098        VISIT_END( Init, node );
    … …  
    19882105        VISIT_START( node );
    19892106
    1990         VISIT(
     2107        if ( __visit_children() ) {
    19912108                maybe_accept( node, &ConstructorInit::ctor );
    19922109                maybe_accept( node, &ConstructorInit::dtor );
    19932110                maybe_accept( node, &ConstructorInit::init );
    1994         )
     2111        }
    19952112
    19962113        VISIT_END( Init, node );
    … …  
    20032120        VISIT_START( node );
    20042121
    2005         VISIT(
     2122        if ( __visit_children() ) {
    20062123                maybe_accept( node, &Attribute::params );
    2007         )
     2124        }
    20082125
    20092126        VISIT_END( Attribute, node );
    … …  
    20162133        VISIT_START( node );
    20172134
    2018         VISIT(
     2135        if ( __visit_children() ) {
    20192136                {
    20202137                        bool mutated = false;
    … …  
    20322149                        }
    20332150                }
    2034         )
     2151        }
    20352152
    20362153        VISIT_END( TypeSubstitution, node );
    … …  
    20382155
    20392156#undef VISIT_START
    2040 #undef VISIT
    20412157#undef VISIT_END

  • src/AST/Print.cpp

    r97c215f rf5a51db  
    333333                print( node->funcSpec );
    334334
    335                 if ( node->type ) {
     335
     336
     337                if ( node->type && node->isTypeFixed ) {
    336338                        node->type->accept( *this );
    337339                } else {
    338                         os << "untyped entity";
     340                        if (!node->type_params.empty()) {
     341                                os << "forall" << endl;
     342                                ++indent;
     343                                printAll(node->type_params);
     344                                os << indent;
     345                                --indent;
     346
     347                                if (!node->assertions.empty()) {
     348                                        os << "with assertions" << endl;
     349                                        ++indent;
     350                                        printAll(node->assertions);
     351                                        os << indent;
     352                                        --indent;
     353                                }
     354                        }
     355
     356                        os << "function" << endl;
     357                        if ( ! node->params.empty() ) {
     358                                os << indent << "... with parameters" << endl;
     359                                ++indent;
     360                                printAll( node->params );
     361                                if ( node->type->isVarArgs ) {
     362                                        os << indent << "and a variable number of other arguments" << endl;
     363                                }
     364                                --indent;
     365                        } else if ( node->type->isVarArgs ) {
     366                                os << indent+1 << "accepting unspecified arguments" << endl;
     367                        }
     368
     369                        os << indent << "... returning";
     370                        if ( node->returns.empty() ) {
     371                                os << " nothing" << endl;
     372                        } else {
     373                                os << endl;
     374                                ++indent;
     375                                printAll( node->returns );
     376                                --indent;
     377                        }
    339378                }
    340379
    … …  
    472511                ++indent;
    473512                os << indent;
    474                 safe_print( node->thenPart );
    475                 --indent;
    476 
    477                 if ( node->elsePart != 0 ) {
     513                safe_print( node->then );
     514                --indent;
     515
     516                if ( node->else_ != 0 ) {
    478517                        os << indent << "... else:" << endl;
    479518                        ++indent;
    480519                        os << indent;
    481                         node->elsePart->accept( *this );
     520                        node->else_->accept( *this );
    482521                        --indent;
    483522                } // if
    … …  
    485524        }
    486525
    487         virtual const ast::Stmt * visit( const ast::WhileStmt * node ) override final {
     526        virtual const ast::Stmt * visit( const ast::WhileDoStmt * node ) override final {
    488527                if ( node->isDoWhile ) { os << "Do-"; }
    489528                os << "While on condition:" << endl;

  • src/AST/Stmt.cpp

    r97c215f rf5a51db  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed May  8 13:00:00 2019
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed May 15 15:53:00 2019
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Feb  2 19:01:20 2022
     13// Update Count     : 3
    1414//
    1515
    … …  
    5656
    5757// --- BranchStmt
    58 BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, std::vector<Label>&& labels )
    59 : Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
     58BranchStmt::BranchStmt( const CodeLocation& loc, Kind kind, Label target, const std::vector<Label>&& labels )
     59                : Stmt(loc, std::move(labels)), originalTarget(target), target(target), kind(kind) {
    6060        // Make sure a syntax error hasn't slipped through.
    6161        assert( Goto != kind || !target.empty() );

  • src/AST/Stmt.hpp

    r97c215f rf5a51db  
    99// Author           : Aaron B. Moss
    1010// Created On       : Wed May  8 13:00:00 2019
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri May 17 12:45:00 2019
    13 // Update Count     : 5
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Feb  2 20:06:41 2022
     13// Update Count     : 34
    1414//
    1515
    … …  
    1717
    1818#include <list>
    19 #include <utility>                // for move
     19#include <utility>                                                                              // for move
    2020#include <vector>
    2121
    2222#include "Label.hpp"
    23 #include "Node.hpp"               // for node, ptr
     23#include "Node.hpp"                                                                             // for node, ptr
    2424#include "ParseNode.hpp"
    2525#include "Visitor.hpp"
    … …  
    2727
    2828// Must be included in *all* AST classes; should be #undef'd at the end of the file
    29 #define MUTATE_FRIEND \
     29#define MUTATE_FRIEND                                                                                                   \
    3030    template<typename node_t> friend node_t * mutate(const node_t * node); \
    3131        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
    3232
    3333namespace ast {
    34 
    3534class Expr;
    3635
    37 /// Base statement node
     36// Base statement node
    3837class Stmt : public ParseNode {
    39 public:
     38  public:
    4039        std::vector<Label> labels;
    4140
    42         Stmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
    43         : ParseNode(loc), labels(std::move(labels)) {}
    44 
    45         Stmt(const Stmt& o) : ParseNode(o), labels(o.labels) {}
     41        Stmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
     42                : ParseNode(loc), labels(std::move(labels)) {}
     43
     44        Stmt(const Stmt & o) : ParseNode(o), labels(o.labels) {}
    4645
    4746        const Stmt * accept( Visitor & v ) const override = 0;
    48 private:
     47  private:
    4948        Stmt * clone() const override = 0;
    5049        MUTATE_FRIEND
    5150};
    5251
    53 /// Compound statement `{ ... }`
     52// Compound statement: { ... }
    5453class CompoundStmt final : public Stmt {
    55 public:
     54  public:
    5655        std::list<ptr<Stmt>> kids;
    5756
    58         CompoundStmt(const CodeLocation & loc, std::list<ptr<Stmt>> && ks = {},
    59                 std::vector<Label>&& labels = {} )
    60         : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
    61 
    62         CompoundStmt( const CompoundStmt& o );
    63         CompoundStmt( CompoundStmt&& o ) = default;
     57        CompoundStmt(const CodeLocation & loc, const std::list<ptr<Stmt>> && ks = {}, const std::vector<Label> && labels = {} )
     58                : Stmt(loc, std::move(labels)), kids(std::move(ks)) {}
     59
     60        CompoundStmt( const CompoundStmt & o );
     61        CompoundStmt( CompoundStmt && o ) = default;
    6462
    6563        void push_back( const Stmt * s ) { kids.emplace_back( s ); }
    … …  
    6765
    6866        const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
    69 private:
     67  private:
    7068        CompoundStmt * clone() const override { return new CompoundStmt{ *this }; }
    7169        MUTATE_FRIEND
    7270};
    7371
    74 /// Empty statment `;`
     72// Empty statment: ;
    7573class NullStmt final : public Stmt {
    76 public:
    77         NullStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
    78         : Stmt(loc, std::move(labels)) {}
     74  public:
     75        NullStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
     76                : Stmt(loc, std::move(labels)) {}
    7977
    8078        const NullStmt * accept( Visitor & v ) const override { return v.visit( this ); }
    81 private:
     79  private:
    8280        NullStmt * clone() const override { return new NullStmt{ *this }; }
    8381        MUTATE_FRIEND
    8482};
    8583
    86 /// Expression wrapped by statement
     84// Expression wrapped by statement
    8785class ExprStmt final : public Stmt {
    88 public:
     86  public:
    8987        ptr<Expr> expr;
    9088
    91         ExprStmt( const CodeLocation& loc, const Expr* e, std::vector<Label>&& labels = {} )
    92         : Stmt(loc, std::move(labels)), expr(e) {}
    93 
    94         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    95 private:
     89        ExprStmt( const CodeLocation & loc, const Expr* e, const std::vector<Label> && labels = {} )
     90                : Stmt(loc, std::move(labels)), expr(e) {}
     91
     92        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     93  private:
    9694        ExprStmt * clone() const override { return new ExprStmt{ *this }; }
    9795        MUTATE_FRIEND
    9896};
    9997
    100 /// Assembly statement `asm ... ( "..." : ... )`
     98// Assembly statement: asm ... ( "..." : ... )
    10199class AsmStmt final : public Stmt {
    102 public:
     100  public:
    103101        bool isVolatile;
    104102        ptr<Expr> instruction;
    … …  
    108106
    109107        AsmStmt( const CodeLocation & loc, bool isVolatile, const Expr * instruction,
    110                 std::vector<ptr<Expr>> && output, std::vector<ptr<Expr>> && input,
    111                 std::vector<ptr<ConstantExpr>> && clobber, std::vector<Label> && gotoLabels,
    112                 std::vector<Label> && labels = {})
    113         : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
    114           output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
    115           gotoLabels(std::move(gotoLabels)) {}
    116 
    117         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    118 private:
     108                         const std::vector<ptr<Expr>> && output, const std::vector<ptr<Expr>> && input,
     109                         const std::vector<ptr<ConstantExpr>> && clobber, const std::vector<Label> && gotoLabels,
     110                         const std::vector<Label> && labels = {})
     111                : Stmt(loc, std::move(labels)), isVolatile(isVolatile), instruction(instruction),
     112                  output(std::move(output)), input(std::move(input)), clobber(std::move(clobber)),
     113                  gotoLabels(std::move(gotoLabels)) {}
     114
     115        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     116  private:
    119117        AsmStmt * clone() const override { return new AsmStmt{ *this }; }
    120118        MUTATE_FRIEND
    121119};
    122120
    123 /// C-preprocessor directive `#...`
     121// C-preprocessor directive: #...
    124122class DirectiveStmt final : public Stmt {
    125 public:
     123  public:
    126124        std::string directive;
    127125
    128126        DirectiveStmt( const CodeLocation & loc, const std::string & directive,
    129                 std::vector<Label> && labels = {} )
    130         : Stmt(loc, std::move(labels)), directive(directive) {}
    131 
    132         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    133 private:
     127                                   std::vector<Label> && labels = {} )
     128                : Stmt(loc, std::move(labels)), directive(directive) {}
     129
     130        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     131  private:
    134132        DirectiveStmt * clone() const override { return new DirectiveStmt{ *this }; }
    135133        MUTATE_FRIEND
    136134};
    137135
    138 /// If conditional statement `if (...) ... else ...`
     136// If statement: if (...) ... else ...
    139137class IfStmt final : public Stmt {
    140 public:
    141         ptr<Expr> cond;
    142         ptr<Stmt> thenPart;
    143         ptr<Stmt> elsePart;
     138  public:
     139        ptr<Expr> cond;
     140        ptr<Stmt> then;
     141        ptr<Stmt> else_;
    144142        std::vector<ptr<Stmt>> inits;
    145143
    146         IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
    147                 const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
    148                 std::vector<Label> && labels = {} )
    149         : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),
    150           inits(std::move(inits)) {}
    151 
    152         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    153 private:
     144        IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * then,
     145                        const Stmt * else_ = nullptr, const std::vector<ptr<Stmt>> && inits = {},
     146                        const std::vector<Label> && labels = {} )
     147                : Stmt(loc, std::move(labels)), cond(cond), then(then), else_(else_),
     148                  inits(std::move(inits)) {}
     149
     150        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     151  private:
    154152        IfStmt * clone() const override { return new IfStmt{ *this }; }
    155153        MUTATE_FRIEND
    156154};
    157155
    158 /// Switch or choose conditional statement `switch (...) { ... }`
     156// Switch or choose statement: switch (...) { ... }
    159157class SwitchStmt final : public Stmt {
    160 public:
     158  public:
    161159        ptr<Expr> cond;
    162160        std::vector<ptr<Stmt>> stmts;
    163161
    164         SwitchStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
    165                 std::vector<Label> && labels = {} )
    166         : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
    167 
    168         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    169 private:
     162        SwitchStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
     163                                const std::vector<Label> && labels = {} )
     164                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
     165
     166        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     167  private:
    170168        SwitchStmt * clone() const override { return new SwitchStmt{ *this }; }
    171169        MUTATE_FRIEND
    172170};
    173171
    174 /// Case label `case ...:` `default:`
     172// Case label: case ...: or default:
    175173class CaseStmt final : public Stmt {
    176 public:
    177         /// Null for the default label.
     174  public:
     175        // Null for the default label.
    178176        ptr<Expr> cond;
    179177        std::vector<ptr<Stmt>> stmts;
    180178
    181         CaseStmt( const CodeLocation & loc, const Expr * cond, std::vector<ptr<Stmt>> && stmts,
    182                 std::vector<Label> && labels = {} )
    183         : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
     179        CaseStmt( const CodeLocation & loc, const Expr * cond, const std::vector<ptr<Stmt>> && stmts,
     180                          const std::vector<Label> && labels = {} )
     181                : Stmt(loc, std::move(labels)), cond(cond), stmts(std::move(stmts)) {}
    184182
    185183        bool isDefault() const { return !cond; }
    186184
    187185        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    188 private:
     186  private:
    189187        CaseStmt * clone() const override { return new CaseStmt{ *this }; }
    190188        MUTATE_FRIEND
    191189};
    192190
    193 /// While loop `while (...) ...` `do ... while (...);
    194 class WhileStmt final : public Stmt {
    195 public:
     191// While loop: while (...) ... else ... or do ... while (...) else ...;
     192class WhileDoStmt final : public Stmt {
     193  public:
    196194        ptr<Expr> cond;
    197195        ptr<Stmt> body;
     196        ptr<Stmt> else_;
    198197        std::vector<ptr<Stmt>> inits;
    199198        bool isDoWhile;
    200199
    201         WhileStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
    202                 std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, std::vector<Label> && labels = {} )
    203         : Stmt(loc, std::move(labels)), cond(cond), body(body), inits(std::move(inits)),
    204           isDoWhile(isDoWhile) {}
    205 
    206         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    207 private:
    208         WhileStmt * clone() const override { return new WhileStmt{ *this }; }
    209         MUTATE_FRIEND
    210 };
    211 
    212 /// For loop `for (... ; ... ; ...) ...`
     200        WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body,
     201                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
     202                : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(nullptr), inits(std::move(inits)), isDoWhile(isDoWhile) {}
     203
     204        WhileDoStmt( const CodeLocation & loc, const Expr * cond, const Stmt * body, const Stmt * else_,
     205                                 const std::vector<ptr<Stmt>> && inits, bool isDoWhile = false, const std::vector<Label> && labels = {} )
     206                : Stmt(loc, std::move(labels)), cond(cond), body(body), else_(else_), inits(std::move(inits)), isDoWhile(isDoWhile) {}
     207
     208        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     209  private:
     210        WhileDoStmt * clone() const override { return new WhileDoStmt{ *this }; }
     211        MUTATE_FRIEND
     212};
     213
     214// For loop: for (... ; ... ; ...) ... else ...
    213215class ForStmt final : public Stmt {
    214 public:
     216  public:
    215217        std::vector<ptr<Stmt>> inits;
    216218        ptr<Expr> cond;
    217219        ptr<Expr> inc;
    218220        ptr<Stmt> body;
    219 
    220         ForStmt( const CodeLocation & loc, std::vector<ptr<Stmt>> && inits, const Expr * cond,
    221                 const Expr * inc, const Stmt * body, std::vector<Label> && labels = {} )
    222         : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc),
    223           body(body) {}
    224 
    225         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    226 private:
     221        ptr<Stmt> else_;
     222
     223        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
     224                         const Expr * inc, const Stmt * body, const std::vector<Label> && label = {} )
     225                : Stmt(loc, std::move(label)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(nullptr) {}
     226
     227        ForStmt( const CodeLocation & loc, const std::vector<ptr<Stmt>> && inits, const Expr * cond,
     228                         const Expr * inc, const Stmt * body, const Stmt * else_, const std::vector<Label> && labels = {} )
     229                : Stmt(loc, std::move(labels)), inits(std::move(inits)), cond(cond), inc(inc), body(body), else_(else_) {}
     230
     231        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     232  private:
    227233        ForStmt * clone() const override { return new ForStmt{ *this }; }
    228234        MUTATE_FRIEND
    229235};
    230236
    231 /// Branch control flow statement `goto ...` `break` `continue` `fallthru`
     237// Branch control flow statement: goto ... or break or continue or fallthru
    232238class BranchStmt final : public Stmt {
    233 public:
     239  public:
    234240        enum Kind { Goto, Break, Continue, FallThrough, FallThroughDefault };
    235241        static constexpr size_t kindEnd = 1 + (size_t)FallThroughDefault;
    … …  
    240246        Kind kind;
    241247
    242         BranchStmt( const CodeLocation & loc, Kind kind, Label target,
    243                 std::vector<Label> && labels = {} );
    244         BranchStmt( const CodeLocation & loc, const Expr * computedTarget,
    245                 std::vector<Label> && labels = {} )
    246         : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc),
    247           computedTarget(computedTarget), kind(Goto) {}
     248        BranchStmt( const CodeLocation & loc, Kind kind, Label target, const std::vector<Label> && labels = {} );
     249        BranchStmt( const CodeLocation & loc, const Expr * computedTarget, const std::vector<Label> && labels = {} )
     250                : Stmt(loc, std::move(labels)), originalTarget(loc), target(loc), computedTarget(computedTarget), kind(Goto) {}
    248251
    249252        const char * kindName() const { return kindNames[kind]; }
    250253
    251254        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    252 private:
     255  private:
    253256        BranchStmt * clone() const override { return new BranchStmt{ *this }; }
    254257        MUTATE_FRIEND
    … …  
    257260};
    258261
    259 /// Return statement `return ...`
     262// Return statement: return ...
    260263class ReturnStmt final : public Stmt {
    261 public:
     264  public:
    262265        ptr<Expr> expr;
    263266
    264         ReturnStmt( const CodeLocation & loc, const Expr * expr, std::vector<Label> && labels = {} )
    265         : Stmt(loc, std::move(labels)), expr(expr) {}
    266 
    267         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    268 private:
     267        ReturnStmt( const CodeLocation & loc, const Expr * expr, const std::vector<Label> && labels = {} )
     268                : Stmt(loc, std::move(labels)), expr(expr) {}
     269
     270        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     271  private:
    269272        ReturnStmt * clone() const override { return new ReturnStmt{ *this }; }
    270273        MUTATE_FRIEND
    271274};
    272275
    273 /// Kind of exception
     276// Kind of exception
    274277enum ExceptionKind { Terminate, Resume };
    275278
    276 /// Throw statement `throw ...`
     279// Throw statement: throw ...
    277280class ThrowStmt final : public Stmt {
    278 public:
     281  public:
    279282        ptr<Expr> expr;
    280283        ptr<Expr> target;
    281284        ExceptionKind kind;
    282285
    283         ThrowStmt(
    284                 const CodeLocation & loc, ExceptionKind kind, const Expr * expr, const Expr * target,
    285                 std::vector<Label> && labels = {} )
    286         : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
    287 
    288         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    289 private:
     286        ThrowStmt( const CodeLocation & loc, ExceptionKind kind, const Expr * expr,
     287                           const Expr * target, const std::vector<Label> && labels = {} )
     288                : Stmt(loc, std::move(labels)), expr(expr), target(target), kind(kind) {}
     289
     290        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     291  private:
    290292        ThrowStmt * clone() const override { return new ThrowStmt{ *this }; }
    291293        MUTATE_FRIEND
    292294};
    293295
    294 /// Try statement `try { ... } ...`
     296// Try statement: try { ... } ...
    295297class TryStmt final : public Stmt {
    296 public:
     298  public:
    297299        ptr<CompoundStmt> body;
    298300        std::vector<ptr<CatchStmt>> handlers;
    299301        ptr<FinallyStmt> finally;
    300302
    301         TryStmt(
    302                 const CodeLocation & loc, const CompoundStmt * body,
    303                 std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
    304                 std::vector<Label> && labels = {} )
    305         : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
    306 
    307         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    308 private:
     303        TryStmt( const CodeLocation & loc, const CompoundStmt * body,
     304                         const std::vector<ptr<CatchStmt>> && handlers, const FinallyStmt * finally,
     305                         const std::vector<Label> && labels = {} )
     306                : Stmt(loc, std::move(labels)), body(body), handlers(std::move(handlers)), finally(finally) {}
     307
     308        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     309  private:
    309310        TryStmt * clone() const override { return new TryStmt{ *this }; }
    310311        MUTATE_FRIEND
    311312};
    312313
    313 /// Catch clause of try statement
     314// Catch clause of try statement
    314315class CatchStmt final : public Stmt {
    315 public:
     316  public:
    316317        ptr<Decl> decl;
    317318        ptr<Expr> cond;
    … …  
    319320        ExceptionKind kind;
    320321
    321         CatchStmt(
    322                 const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
    323                 const Stmt * body, std::vector<Label> && labels = {} )
    324         : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
    325 
    326         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    327 private:
     322        CatchStmt( const CodeLocation & loc, ExceptionKind kind, const Decl * decl, const Expr * cond,
     323                           const Stmt * body, const std::vector<Label> && labels = {} )
     324                : Stmt(loc, std::move(labels)), decl(decl), cond(cond), body(body), kind(kind) {}
     325
     326        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     327  private:
    328328        CatchStmt * clone() const override { return new CatchStmt{ *this }; }
    329329        MUTATE_FRIEND
    330330};
    331331
    332 /// Finally clause of try statement
     332// Finally clause of try statement
    333333class FinallyStmt final : public Stmt {
    334 public:
     334  public:
    335335        ptr<CompoundStmt> body;
    336336
    337337        FinallyStmt( const CodeLocation & loc, const CompoundStmt * body,
    338                 std::vector<Label> && labels = {} )
    339         : Stmt(loc, std::move(labels)), body(body) {}
    340 
    341         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    342 private:
     338                                 std::vector<Label> && labels = {} )
     339                : Stmt(loc, std::move(labels)), body(body) {}
     340
     341        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     342  private:
    343343        FinallyStmt * clone() const override { return new FinallyStmt{ *this }; }
    344344        MUTATE_FRIEND
    345345};
    346346
    347 /// Suspend statement
     347// Suspend statement
    348348class SuspendStmt final : public Stmt {
    349 public:
     349  public:
    350350        ptr<CompoundStmt> then;
    351351        enum Type { None, Coroutine, Generator } type = None;
    352352
    353         SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
    354         : Stmt(loc, std::move(labels)), then(then), type(type) {}
    355 
    356         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    357 private:
     353        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, const std::vector<Label> && labels = {} )
     354                : Stmt(loc, std::move(labels)), then(then), type(type) {}
     355
     356        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     357  private:
    358358        SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
    359359        MUTATE_FRIEND
    360360};
    361361
    362 /// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
     362// Waitfor statement: when (...) waitfor (... , ...) ... timeout(...) ... else ...
    363363class WaitForStmt final : public Stmt {
    364 public:
     364  public:
    365365        struct Target {
    366366                ptr<Expr> func;
    … …  
    389389        OrElse orElse;
    390390
    391         WaitForStmt( const CodeLocation & loc, std::vector<Label> && labels = {} )
    392         : Stmt(loc, std::move(labels)) {}
    393 
    394         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    395 private:
     391        WaitForStmt( const CodeLocation & loc, const std::vector<Label> && labels = {} )
     392                : Stmt(loc, std::move(labels)) {}
     393
     394        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     395  private:
    396396        WaitForStmt * clone() const override { return new WaitForStmt{ *this }; }
    397397        MUTATE_FRIEND
    398398};
    399399
    400 /// Any declaration in a (compound) statement.
     400// Any declaration in a (compound) statement.
    401401class DeclStmt final : public Stmt {
    402 public:
     402  public:
    403403        ptr<Decl> decl;
    404404
    405         DeclStmt( const CodeLocation & loc, const Decl * decl, std::vector<Label> && labels = {} )
    406         : Stmt(loc, std::move(labels)), decl(decl) {}
    407 
    408         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    409 private:
     405        DeclStmt( const CodeLocation & loc, const Decl * decl, const std::vector<Label> && labels = {} )
     406                : Stmt(loc, std::move(labels)), decl(decl) {}
     407
     408        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     409  private:
    410410        DeclStmt * clone() const override { return new DeclStmt{ *this }; }
    411411        MUTATE_FRIEND
    412412};
    413413
    414 /// Represents an implicit application of a constructor or destructor.
     414// Represents an implicit application of a constructor or destructor.
    415415class ImplicitCtorDtorStmt final : public Stmt {
    416 public:
     416  public:
    417417        ptr<Stmt> callStmt;
    418418
    419419        ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,
    420                 std::vector<Label> && labels = {} )
    421         : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
    422 
    423         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    424 private:
     420                                                  std::vector<Label> && labels = {} )
     421                : Stmt(loc, std::move(labels)), callStmt(callStmt) {}
     422
     423        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     424  private:
    425425        ImplicitCtorDtorStmt * clone() const override { return new ImplicitCtorDtorStmt{ *this }; }
    426426        MUTATE_FRIEND
    427427};
    428428
    429 /// Mutex Statement
     429// Mutex Statement
    430430class MutexStmt final : public Stmt {
    431 public:
     431  public:
    432432        ptr<Stmt> stmt;
    433433        std::vector<ptr<Expr>> mutexObjs;
    434434
    435435        MutexStmt( const CodeLocation & loc, const Stmt * stmt,
    436                 std::vector<ptr<Expr>> && mutexes, std::vector<Label> && labels = {} )
    437         : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
    438 
    439         const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
    440 private:
     436                           const std::vector<ptr<Expr>> && mutexes, const std::vector<Label> && labels = {} )
     437                : Stmt(loc, std::move(labels)), stmt(stmt), mutexObjs(std::move(mutexes)) {}
     438
     439        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
     440  private:
    441441        MutexStmt * clone() const override { return new MutexStmt{ *this }; }
    442442        MUTATE_FRIEND
    443443};
    444 
    445 }
     444} // namespace ast
    446445
    447446#undef MUTATE_FRIEND
    448447
    449448// Local Variables: //
    450 // tab-width: 4 //
    451449// mode: c++ //
    452 // compile-command: "make install" //
    453450// End: //

  • src/AST/Visitor.hpp

    r97c215f rf5a51db  
    1010// Created On       : Thr May 9 15:28:00 2019
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:25:07 2021
    13 // Update Count     : 1
     12// Last Modified On : Tue Feb  1 09:09:34 2022
     13// Update Count     : 2
    1414//
    1515
    … …  
    3838    virtual const ast::Stmt *             visit( const ast::DirectiveStmt        * ) = 0;
    3939    virtual const ast::Stmt *             visit( const ast::IfStmt               * ) = 0;
    40     virtual const ast::Stmt *             visit( const ast::WhileStmt            * ) = 0;
     40    virtual const ast::Stmt *             visit( const ast::WhileDoStmt          * ) = 0;
    4141    virtual const ast::Stmt *             visit( const ast::ForStmt              * ) = 0;
    4242    virtual const ast::Stmt *             visit( const ast::SwitchStmt           * ) = 0;

  • src/CodeGen/CodeGenerator.cc

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 19:00:42 2021
    13 // Update Count     : 536
     12// Last Modified On : Wed Feb  2 20:30:30 2022
     13// Update Count     : 541
    1414//
    1515#include "CodeGenerator.h"
    … …  
    4242        bool wantSpacing( Statement * stmt) {
    4343                return dynamic_cast< IfStmt * >( stmt ) || dynamic_cast< CompoundStmt * >( stmt ) ||
    44                         dynamic_cast< WhileStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
     44                        dynamic_cast< WhileDoStmt * >( stmt ) || dynamic_cast< ForStmt * >( stmt ) || dynamic_cast< SwitchStmt *>( stmt );
    4545        }
    4646
    … …  
    955955                output << " ) ";
    956956
    957                 ifStmt->get_thenPart()->accept( *visitor );
    958 
    959                 if ( ifStmt->get_elsePart() != 0) {
     957                ifStmt->get_then()->accept( *visitor );
     958
     959                if ( ifStmt->get_else() != 0) {
    960960                        output << " else ";
    961                         ifStmt->get_elsePart()->accept( *visitor );
     961                        ifStmt->get_else()->accept( *visitor );
    962962                } // if
    963963        }
    … …  
    10201020                        output << "fallthru";
    10211021                        break;
     1022                  default: ;                                                                    // prevent warning
    10221023                } // switch
    10231024                // print branch target for labelled break/continue/fallthru in debug mode
    … …  
    11251126        }
    11261127
    1127         void CodeGenerator::postvisit( WhileStmt * whileStmt ) {
    1128                 if ( whileStmt->get_isDoWhile() ) {
     1128        void CodeGenerator::postvisit( WhileDoStmt * whileDoStmt ) {
     1129                if ( whileDoStmt->get_isDoWhile() ) {
    11291130                        output << "do";
    11301131                } else {
    11311132                        output << "while (";
    1132                         whileStmt->get_condition()->accept( *visitor );
     1133                        whileDoStmt->get_condition()->accept( *visitor );
    11331134                        output << ")";
    11341135                } // if
    11351136                output << " ";
    11361137
    1137                 output << CodeGenerator::printLabels( whileStmt->get_body()->get_labels() );
    1138                 whileStmt->get_body()->accept( *visitor );
     1138                output << CodeGenerator::printLabels( whileDoStmt->get_body()->get_labels() );
     1139                whileDoStmt->get_body()->accept( *visitor );
    11391140
    11401141                output << indent;
    11411142
    1142                 if ( whileStmt->get_isDoWhile() ) {
     1143                if ( whileDoStmt->get_isDoWhile() ) {
    11431144                        output << " while (";
    1144                         whileStmt->get_condition()->accept( *visitor );
     1145                        whileDoStmt->get_condition()->accept( *visitor );
    11451146                        output << ");";
    11461147                } // if

  • src/CodeGen/CodeGenerator.h

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:38 2021
    13 // Update Count     : 63
     12// Last Modified On : Tue Feb  1 09:23:21 2022
     13// Update Count     : 64
    1414//
    1515
    … …  
    116116                void postvisit( WaitForStmt * );
    117117                void postvisit( WithStmt * );
    118                 void postvisit( WhileStmt * );
     118                void postvisit( WhileDoStmt * );
    119119                void postvisit( ForStmt * );
    120120                void postvisit( NullStmt * );

  • src/Common/CodeLocationTools.cpp

    r97c215f rf5a51db  
    1010// Created On       : Fri Dec  4 15:42:00 2020
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:37 2021
    13 // Update Count     : 2
     12// Last Modified On : Tue Feb  1 09:14:39 2022
     13// Update Count     : 3
    1414//
    1515
    … …  
    109109    macro(DirectiveStmt, Stmt) \
    110110    macro(IfStmt, Stmt) \
    111     macro(WhileStmt, Stmt) \
     111    macro(WhileDoStmt, Stmt) \
    112112    macro(ForStmt, Stmt) \
    113113    macro(SwitchStmt, Stmt) \

  • src/Common/PassVisitor.h

    r97c215f rf5a51db  
    9292        virtual void visit( IfStmt * ifStmt ) override final;
    9393        virtual void visit( const IfStmt * ifStmt ) override final;
    94         virtual void visit( WhileStmt * whileStmt ) override final;
    95         virtual void visit( const WhileStmt * whileStmt ) override final;
     94        virtual void visit( WhileDoStmt * whileDoStmt ) override final;
     95        virtual void visit( const WhileDoStmt * whileDoStmt ) override final;
    9696        virtual void visit( ForStmt * forStmt ) override final;
    9797        virtual void visit( const ForStmt * forStmt ) override final;
    … …  
    277277        virtual Statement * mutate( DirectiveStmt * dirStmt ) override final;
    278278        virtual Statement * mutate( IfStmt * ifStmt ) override final;
    279         virtual Statement * mutate( WhileStmt * whileStmt ) override final;
     279        virtual Statement * mutate( WhileDoStmt * whileDoStmt ) override final;
    280280        virtual Statement * mutate( ForStmt * forStmt ) override final;
    281281        virtual Statement * mutate( SwitchStmt * switchStmt ) override final;

  • src/Common/PassVisitor.impl.h

    r97c215f rf5a51db  
    11891189                maybeAccept_impl( node->initialization, *this );
    11901190                visitExpression ( node->condition );
    1191                 node->thenPart = visitStatement( node->thenPart );
    1192                 node->elsePart = visitStatement( node->elsePart );
     1191                node->then = visitStatement( node->then );
     1192                node->else_ = visitStatement( node->else_ );
    11931193        }
    11941194        VISIT_END( node );
    … …  
    12031203                maybeAccept_impl( node->initialization, *this );
    12041204                visitExpression ( node->condition );
    1205                 visitStatement  ( node->thenPart );
    1206                 visitStatement  ( node->elsePart );
     1205                visitStatement  ( node->then );
     1206                visitStatement  ( node->else_ );
    12071207        }
    12081208        VISIT_END( node );
    … …  
    12171217                maybeMutate_impl( node->initialization, *this );
    12181218                node->condition = mutateExpression( node->condition );
    1219                 node->thenPart  = mutateStatement ( node->thenPart  );
    1220                 node->elsePart  = mutateStatement ( node->elsePart  );
     1219                node->then  = mutateStatement ( node->then  );
     1220                node->else_  = mutateStatement ( node->else_  );
    12211221        }
    12221222        MUTATE_END( Statement, node );
    … …  
    12241224
    12251225//--------------------------------------------------------------------------
    1226 // WhileStmt
    1227 template< typename pass_type >
    1228 void PassVisitor< pass_type >::visit( WhileStmt * node ) {
     1226// WhileDoStmt
     1227template< typename pass_type >
     1228void PassVisitor< pass_type >::visit( WhileDoStmt * node ) {
    12291229        VISIT_START( node );
    12301230
    … …  
    12411241
    12421242template< typename pass_type >
    1243 void PassVisitor< pass_type >::visit( const WhileStmt * node ) {
     1243void PassVisitor< pass_type >::visit( const WhileDoStmt * node ) {
    12441244        VISIT_START( node );
    12451245
    … …  
    12561256
    12571257template< typename pass_type >
    1258 Statement * PassVisitor< pass_type >::mutate( WhileStmt * node ) {
     1258Statement * PassVisitor< pass_type >::mutate( WhileDoStmt * node ) {
    12591259        MUTATE_START( node );
    12601260

  • src/Common/utility.h

    r97c215f rf5a51db  
    371371}
    372372
     373template< typename T >
     374struct enumerate_t {
     375        template<typename val_t>
     376        struct value_t {
     377                val_t & val;
     378                size_t idx;
     379        };
     380
     381        template< typename iter_t, typename val_t >
     382        struct iterator_t {
     383                iter_t it;
     384                size_t idx;
     385
     386                iterator_t( iter_t _it, size_t _idx ) : it(_it), idx(_idx) {}
     387
     388                value_t<val_t> operator*() const { return value_t<val_t>{ *it, idx }; }
     389
     390                bool operator==(const iterator_t & o) const { return o.it == it; }
     391                bool operator!=(const iterator_t & o) const { return o.it != it; }
     392
     393                iterator_t & operator++() {
     394                        it++;
     395                        idx++;
     396                        return *this;
     397                }
     398
     399                using difference_type   = typename std::iterator_traits< iter_t >::difference_type;
     400                using value_type        = value_t<val_t>;
     401                using pointer           = value_t<val_t> *;
     402                using reference         = value_t<val_t> &;
     403                using iterator_category = std::forward_iterator_tag;
     404        };
     405
     406        T & ref;
     407
     408        using iterator = iterator_t< typename T::iterator, typename T::value_type >;
     409        using const_iterator = iterator_t< typename T::const_iterator, const typename T::value_type >;
     410
     411        iterator begin() { return iterator( ref.begin(), 0 ); }
     412        iterator end()   { return iterator( ref.end(), ref.size() ); }
     413
     414        const_iterator begin() const { return const_iterator( ref.cbegin(), 0 ); }
     415        const_iterator end()   const { return const_iterator( ref.cend(), ref.size() ); }
     416
     417        const_iterator cbegin() const { return const_iterator( ref.cbegin(), 0 ); }
     418        const_iterator cend()   const { return const_iterator( ref.cend(), ref.size() ); }
     419};
     420
     421template< typename T >
     422enumerate_t<T> enumerate( T & ref ) {
     423        return enumerate_t< T >{ ref };
     424}
     425
     426template< typename T >
     427const enumerate_t< const T > enumerate( const T & ref ) {
     428        return enumerate_t< const T >{ ref };
     429}
     430
    373431template< typename OutType, typename Range, typename Functor >
    374432OutType map_range( const Range& range, Functor&& functor ) {

  • src/ControlStruct/ExceptTranslate.h

    r97c215f rf5a51db  
    3131
    3232        void translateTries( std::list< Declaration *> & translationUnit );
     33        void translateTries( ast::TranslationUnit & transUnit );
    3334        /* Replaces all try blocks (and their many clauses) with function definitions and calls.
    3435         * This uses the exception built-ins to produce typed output and should take place after

  • src/ControlStruct/ExceptTranslateNew.cpp

    r97c215f rf5a51db  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  8 11:53:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 16:50:00 2021
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 18:49:58 2022
     13// Update Count     : 1
    1414//
    1515
    … …  
    2020#include "AST/Stmt.hpp"
    2121#include "AST/TranslationUnit.hpp"
     22#include "AST/DeclReplacer.hpp"
    2223
    2324namespace ControlStruct {
    2425
    2526namespace {
     27
     28        typedef std::list<ast::CatchStmt*> CatchList;
     29
     30        void split( CatchList& allHandlers, CatchList& terHandlers,
     31                                CatchList& resHandlers ) {
     32                while ( !allHandlers.empty() ) {
     33                        ast::CatchStmt * stmt = allHandlers.front();
     34                        allHandlers.pop_front();
     35                        if (stmt->kind == ast::ExceptionKind::Terminate) {
     36                                terHandlers.push_back(stmt);
     37                        } else {
     38                                resHandlers.push_back(stmt);
     39                        }
     40                }
     41        }
     42
     43        void appendDeclStmt( ast::CompoundStmt * block, ast::DeclWithType * item ) {
     44                block->push_back(new ast::DeclStmt(block->location, item));
     45        }
    2646
    2747class TranslateThrowsCore : public ast::WithGuards {
    … …  
    128148}
    129149
     150
     151class TryMutatorCore {
     152        // The built in types used in translation.
     153        const ast::StructDecl * except_decl;
     154        const ast::StructDecl * node_decl;
     155        const ast::StructDecl * hook_decl;
     156
     157        // The many helper functions for code/syntree generation.
     158        ast::CompoundStmt * take_try_block( ast::TryStmt * tryStmt );
     159        ast::FunctionDecl * create_try_wrapper( const ast::CompoundStmt * body );
     160        ast::FunctionDecl * create_terminate_catch( CatchList &handlers );
     161        ast::CompoundStmt * create_single_matcher(
     162                const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler );
     163        ast::FunctionDecl * create_terminate_match( CatchList &handlers );
     164        ast::CompoundStmt * create_terminate_caller( CodeLocation loc, ast::FunctionDecl * try_wrapper,
     165                ast::FunctionDecl * terminate_catch, ast::FunctionDecl * terminate_match );
     166        ast::FunctionDecl * create_resume_handler( CatchList &handlers );
     167        ast::CompoundStmt * create_resume_wrapper(
     168                const ast::Stmt * wraps, const ast::FunctionDecl * resume_handler );
     169        ast::FunctionDecl * create_finally_wrapper( ast::TryStmt * tryStmt );
     170        ast::ObjectDecl * create_finally_hook( ast::FunctionDecl * finally_wrapper );
     171        ast::Stmt * create_resume_rethrow( const ast::ThrowStmt * throwStmt );
     172
     173        // Types used in translation, make sure to use clone.
     174        // void (*function)();
     175        ast::FunctionDecl * try_func_t;
     176        // void (*function)(int, exception);
     177        ast::FunctionDecl * catch_func_t;
     178        // int (*function)(exception);
     179        ast::FunctionDecl * match_func_t;
     180        // bool (*function)(exception);
     181        ast::FunctionDecl * handle_func_t;
     182        // void (*function)(__attribute__((unused)) void *);
     183        ast::FunctionDecl * finally_func_t;
     184
     185        ast::StructInstType * create_except_type() {
     186                assert( except_decl );
     187                return new ast::StructInstType( except_decl );
     188        }
     189        void init_func_types();
     190
     191public:
     192        TryMutatorCore() :
     193                except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr )
     194        {}
     195
     196        void previsit( const ast::StructDecl *structDecl );
     197        ast::Stmt * postvisit( const ast::TryStmt *tryStmt );
     198        ast::Stmt * postvisit( const ast::ThrowStmt *throwStmt );
     199};
     200
     201void TryMutatorCore::init_func_types() {
     202        assert( except_decl );
     203
     204        ast::ObjectDecl index_obj(
     205                {},
     206                "__handler_index",
     207                new ast::BasicType(ast::BasicType::SignedInt)
     208                );
     209        ast::ObjectDecl exception_obj(
     210                {},
     211                "__exception_inst",
     212                new ast::PointerType(
     213                        new ast::StructInstType( except_decl )
     214                        ),
     215                NULL
     216                );
     217        ast::ObjectDecl bool_obj(
     218                {},
     219                "__ret_bool",
     220                new ast::BasicType( ast::BasicType::Bool ),
     221                nullptr, //init
     222                ast::Storage::Classes{},
     223                ast::Linkage::Cforall,
     224                nullptr, //width
     225                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
     226                );
     227        ast::ObjectDecl voidptr_obj(
     228                {},
     229                "__hook",
     230                new ast::PointerType(
     231                        new ast::VoidType()
     232                ),
     233                nullptr, //init
     234                ast::Storage::Classes{},
     235                ast::Linkage::Cforall,
     236                nullptr, //width
     237                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
     238                );
     239
     240        ast::ObjectDecl unused_index_obj(
     241                {},
     242                "__handler_index",
     243                new ast::BasicType(ast::BasicType::SignedInt),
     244                nullptr,
     245                ast::Storage::Classes{},
     246                ast::Linkage::Cforall,
     247                nullptr, //width
     248                std::vector<ast::ptr<ast::Attribute>>{ new ast::Attribute( "unused" ) }
     249        );
     250        //unused_index_obj->attributes.push_back( new Attribute( "unused" ) );
     251
     252        try_func_t = new ast::FunctionDecl(
     253                {},
     254                "try",
     255                {}, //forall
     256                {}, //no param
     257                {}, //no return
     258                nullptr,
     259                ast::Storage::Classes{},
     260                ast::Linkage::Cforall
     261        );
     262
     263        catch_func_t = new ast::FunctionDecl(
     264                {},
     265                "catch",
     266                {}, //forall
     267                {ast::deepCopy(&index_obj), ast::deepCopy(&exception_obj)},//param
     268                {}, //return void
     269                nullptr,
     270                ast::Storage::Classes{},
     271                ast::Linkage::Cforall
     272        );
     273
     274        match_func_t = new ast::FunctionDecl(
     275                {},
     276                "match",
     277                {}, //forall
     278                {ast::deepCopy(&exception_obj)},
     279                {ast::deepCopy(&unused_index_obj)},
     280                nullptr,
     281                ast::Storage::Classes{},
     282                ast::Linkage::Cforall
     283        );
     284
     285        handle_func_t = new ast::FunctionDecl(
     286                {},
     287                "handle",
     288                {}, //forall
     289                {ast::deepCopy(&exception_obj)},
     290                {ast::deepCopy(&bool_obj)},
     291                nullptr,
     292                ast::Storage::Classes{},
     293                ast::Linkage::Cforall
     294        );
     295
     296        finally_func_t = new ast::FunctionDecl(
     297                {},
     298                "finally",
     299                {}, //forall
     300                {ast::deepCopy(&voidptr_obj)},
     301                {}, //return void
     302                nullptr,
     303                ast::Storage::Classes{},
     304                ast::Linkage::Cforall
     305        );
     306
     307        //catch_func_t.get_parameters().push_back( index_obj.clone() );
     308        //catch_func_t.get_parameters().push_back( exception_obj.clone() );
     309        //match_func_t.get_returnVals().push_back( unused_index_obj );
     310        //match_func_t.get_parameters().push_back( exception_obj.clone() );
     311        //handle_func_t.get_returnVals().push_back( bool_obj.clone() );
     312        //handle_func_t.get_parameters().push_back( exception_obj.clone() );
     313        //finally_func_t.get_parameters().push_back( voidptr_obj.clone() );
     314}
     315
     316// TryStmt Mutation Helpers
     317
     318/*
     319ast::CompoundStmt * TryMutatorCore::take_try_block( ast::TryStmt *tryStmt ) {
     320        ast::CompoundStmt * block = tryStmt->body;
     321        tryStmt->body = nullptr;
     322        return block;
     323}
     324*/
     325
     326ast::FunctionDecl * TryMutatorCore::create_try_wrapper(
     327                const ast::CompoundStmt *body ) {
     328
     329        ast::FunctionDecl * ret = ast::deepCopy(try_func_t);
     330        ret->stmts = body;
     331        return ret;
     332}
     333
     334ast::FunctionDecl * TryMutatorCore::create_terminate_catch(
     335                CatchList &handlers ) {
     336        std::vector<ast::ptr<ast::Stmt>> handler_wrappers;
     337
     338        assert (!handlers.empty());
     339        const CodeLocation loc = handlers.front()->location;
     340
     341        ast::FunctionDecl * func_t = ast::deepCopy(catch_func_t);
     342        const ast::DeclWithType * index_obj = func_t->params.front();
     343        const ast::DeclWithType * except_obj = func_t->params.back();
     344
     345        // Index 1..{number of handlers}
     346        int index = 0;
     347        CatchList::iterator it = handlers.begin();
     348        for ( ; it != handlers.end() ; ++it ) {
     349                ++index;
     350                ast::CatchStmt * handler = *it;
     351                const CodeLocation loc = handler->location;
     352
     353                // case `index`:
     354                // {
     355                //     `handler.decl` = { (virtual `decl.type`)`except` };
     356                //     `handler.body`;
     357                // }
     358                // return;
     359                ast::CompoundStmt * block = new ast::CompoundStmt(loc);
     360
     361                // Just copy the exception value. (Post Validation)
     362                const ast::ObjectDecl * handler_decl =
     363                        handler->decl.strict_as<ast::ObjectDecl>();
     364                ast::ObjectDecl * local_except = ast::deepCopy(handler_decl);
     365                ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc,
     366                        new ast::VariableExpr( loc, except_obj ),
     367                        local_except->get_type()
     368                        );
     369                vcex->location = handler->location;
     370                local_except->init = new ast::ListInit(loc, { new ast::SingleInit( loc, vcex ) });
     371                block->push_back( new ast::DeclStmt( loc, local_except ) );
     372
     373                // Add the cleanup attribute.
     374                local_except->attributes.push_back( new ast::Attribute(
     375                        "cleanup",
     376                        { new ast::NameExpr( loc, "__cfaehm_cleanup_terminate" ) }
     377                        ) );
     378
     379                ast::DeclReplacer::DeclMap mapping;
     380                mapping[handler_decl] = local_except;
     381                const ast::Stmt * mutBody = strict_dynamic_cast<const ast::Stmt *>(
     382                        ast::DeclReplacer::replace(handler->body, mapping));
     383
     384
     385                block->push_back( mutBody );
     386                // handler->body = nullptr;
     387
     388                handler_wrappers.push_back( new ast::CaseStmt(loc,
     389                        ast::ConstantExpr::from_int(loc, index) ,
     390                        { block, new ast::ReturnStmt( loc, nullptr ) }
     391                        ));
     392        }
     393        // TODO: Some sort of meaningful error on default perhaps?
     394
     395        /*
     396        std::list<Statement*> stmt_handlers;
     397        while ( !handler_wrappers.empty() ) {
     398                stmt_handlers.push_back( handler_wrappers.front() );
     399                handler_wrappers.pop_front();
     400        }
     401        */
     402
     403        ast::SwitchStmt * handler_lookup = new ast::SwitchStmt(loc,
     404                new ast::VariableExpr( loc, index_obj ),
     405                std::move(handler_wrappers)
     406                );
     407        ast::CompoundStmt * body = new ast::CompoundStmt(loc,
     408                {handler_lookup});
     409
     410        func_t->stmts = body;
     411        return func_t;
     412}
     413
     414// Create a single check from a moddified handler.
     415// except_obj is referenced, modded_handler will be freed.
     416ast::CompoundStmt * TryMutatorCore::create_single_matcher(
     417                const ast::DeclWithType * except_obj, ast::CatchStmt * modded_handler ) {
     418        // {
     419        //     `modded_handler.decl`
     420        //     if ( `decl.name = (virtual `decl.type`)`except`
     421        //             [&& `modded_handler.cond`] ) {
     422        //         `modded_handler.body`
     423        //     }
     424        // }
     425
     426        const CodeLocation loc = modded_handler->location;
     427        ast::CompoundStmt * block = new ast::CompoundStmt(loc);
     428
     429        // Local Declaration
     430        const ast::ObjectDecl * local_except =
     431                modded_handler->decl.strict_as<ast::ObjectDecl>();
     432        block->push_back( new ast::DeclStmt( loc,  local_except ) );
     433
     434        // Check for type match.
     435        ast::VirtualCastExpr * vcex = new ast::VirtualCastExpr(loc,
     436                new ast::VariableExpr(loc, except_obj ),
     437                local_except->get_type()
     438                );
     439        ast::Expr * cond = ast::UntypedExpr::createAssign(loc,
     440                new ast::VariableExpr(loc, local_except ), vcex );
     441
     442        // Add the check on the conditional if it is provided.
     443        if ( modded_handler->cond ) {
     444                cond = new ast::LogicalExpr( loc, cond, modded_handler->cond, ast::LogicalFlag::AndExpr );
     445        }
     446        // Construct the match condition.
     447        block->push_back( new ast::IfStmt(loc,
     448                cond, modded_handler->body, nullptr ) );
     449
     450        // xxx - how does this work in new ast
     451        //modded_handler->set_decl( nullptr );
     452        //modded_handler->set_cond( nullptr );
     453        //modded_handler->set_body( nullptr );
     454        //delete modded_handler;
     455        return block;
     456}
     457
     458ast::FunctionDecl * TryMutatorCore::create_terminate_match(
     459                CatchList &handlers ) {
     460        // int match(exception * except) {
     461        //     HANDLER WRAPPERS { return `index`; }
     462        // }
     463
     464        assert (!handlers.empty());
     465        const CodeLocation loc = handlers.front()->location;
     466
     467        ast::CompoundStmt * body = new ast::CompoundStmt(loc);
     468
     469        ast::FunctionDecl * func_t = ast::deepCopy(match_func_t);
     470        const ast::DeclWithType * except_obj = func_t->params.back();
     471
     472        // Index 1..{number of handlers}
     473        int index = 0;
     474        CatchList::iterator it;
     475        for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
     476                ++index;
     477                ast::CatchStmt * handler = *it;
     478
     479                // Body should have been taken by create_terminate_catch.
     480                // xxx - just ignore it?
     481                // assert( nullptr == handler->get_body() );
     482
     483                // Create new body.
     484                handler->body = new ast::ReturnStmt( handler->location,
     485                        ast::ConstantExpr::from_int( handler->location, index ) );
     486
     487                // Create the handler.
     488                body->push_back( create_single_matcher( except_obj, handler ) );
     489                *it = nullptr;
     490        }
     491
     492        body->push_back( new ast::ReturnStmt(loc,
     493                ast::ConstantExpr::from_int( loc, 0 ) ));
     494
     495        func_t->stmts = body;
     496
     497        return func_t;
     498}
     499
     500ast::CompoundStmt * TryMutatorCore::create_terminate_caller(
     501                CodeLocation loc,
     502                ast::FunctionDecl * try_wrapper,
     503                ast::FunctionDecl * terminate_catch,
     504                ast::FunctionDecl * terminate_match ) {
     505        // { __cfaehm_try_terminate(`try`, `catch`, `match`); }
     506
     507        ast::UntypedExpr * caller = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
     508                "__cfaehm_try_terminate" ) );
     509        caller->args.push_back( new ast::VariableExpr(loc, try_wrapper ) );
     510        caller->args.push_back( new ast::VariableExpr(loc, terminate_catch ) );
     511        caller->args.push_back( new ast::VariableExpr(loc, terminate_match ) );
     512
     513        ast::CompoundStmt * callStmt = new ast::CompoundStmt(loc);
     514        callStmt->push_back( new ast::ExprStmt( loc, caller ) );
     515        return callStmt;
     516}
     517
     518ast::FunctionDecl * TryMutatorCore::create_resume_handler(
     519                CatchList &handlers ) {
     520        // bool handle(exception * except) {
     521        //     HANDLER WRAPPERS { `hander->body`; return true; }
     522        // }
     523        assert (!handlers.empty());
     524        const CodeLocation loc = handlers.front()->location;
     525        ast::CompoundStmt * body = new ast::CompoundStmt(loc);
     526
     527        ast::FunctionDecl * func_t = ast::deepCopy(handle_func_t);
     528        const ast::DeclWithType * except_obj = func_t->params.back();
     529
     530        CatchList::iterator it;
     531        for ( it = handlers.begin() ; it != handlers.end() ; ++it ) {
     532                ast::CatchStmt * handler = *it;
     533                const CodeLocation loc = handler->location;
     534                // Modifiy body.
     535                ast::CompoundStmt * handling_code;
     536                if (handler->body.as<ast::CompoundStmt>()) {
     537                        handling_code =
     538                        strict_dynamic_cast<ast::CompoundStmt*>( handler->body.get_and_mutate() );
     539                } else {
     540                        handling_code = new ast::CompoundStmt(loc);
     541                        handling_code->push_back( handler->body );
     542                }
     543                handling_code->push_back( new ast::ReturnStmt(loc,
     544                        ast::ConstantExpr::from_bool(loc, true ) ) );
     545                handler->body = handling_code;
     546
     547                // Create the handler.
     548                body->push_back( create_single_matcher( except_obj, handler ) );
     549                *it = nullptr;
     550        }
     551
     552        body->push_back( new ast::ReturnStmt(loc,
     553                ast::ConstantExpr::from_bool(loc, false ) ) );
     554        func_t->stmts = body;
     555
     556        return func_t;
     557}
     558
     559ast::CompoundStmt * TryMutatorCore::create_resume_wrapper(
     560                const ast::Stmt * wraps,
     561                const ast::FunctionDecl * resume_handler ) {
     562        const CodeLocation loc = wraps->location;
     563        ast::CompoundStmt * body = new ast::CompoundStmt(loc);
     564
     565        // struct __try_resume_node __resume_node
     566        //      __attribute__((cleanup( __cfaehm_try_resume_cleanup )));
     567        // ** unwinding of the stack here could cause problems **
     568        // ** however I don't think that can happen currently **
     569        // __cfaehm_try_resume_setup( &__resume_node, resume_handler );
     570
     571        ast::ObjectDecl * obj = new ast::ObjectDecl(
     572                loc,
     573                "__resume_node",
     574                new ast::StructInstType(
     575                        node_decl
     576                        ),
     577                nullptr,
     578                ast::Storage::Classes{},
     579                ast::Linkage::Cforall,
     580                nullptr,
     581                {new ast::Attribute("cleanup", {new ast::NameExpr(loc, "__cfaehm_try_resume_cleanup")})}
     582                );
     583        appendDeclStmt( body, obj );
     584
     585        ast::UntypedExpr *setup = new ast::UntypedExpr(loc, new ast::NameExpr(loc,
     586                "__cfaehm_try_resume_setup" ) );
     587        setup->args.push_back( new ast::AddressExpr( loc, new ast::VariableExpr(loc, obj ) ) );
     588        setup->args.push_back( new ast::VariableExpr( loc, resume_handler ) );
     589
     590        body->push_back( new ast::ExprStmt(loc, setup ) );
     591
     592        body->push_back( wraps );
     593        return body;
     594}
     595
     596ast::FunctionDecl * TryMutatorCore::create_finally_wrapper(
     597                ast::TryStmt * tryStmt ) {
     598        // void finally() { `finally->block` }
     599        const ast::FinallyStmt * finally = tryStmt->finally;
     600        const ast::CompoundStmt * body = finally->body;
     601
     602        ast::FunctionDecl * func_t = ast::deepCopy(finally_func_t);
     603        func_t->stmts = body;
     604
     605        // finally->set_block( nullptr );
     606        // delete finally;
     607        tryStmt->finally = nullptr;
     608
     609
     610        return func_t;
     611}
     612
     613ast::ObjectDecl * TryMutatorCore::create_finally_hook(
     614                ast::FunctionDecl * finally_wrapper ) {
     615        // struct __cfaehm_cleanup_hook __finally_hook
     616        //      __attribute__((cleanup( `finally_wrapper` )));
     617
     618        const CodeLocation loc = finally_wrapper->location;
     619        // Make Cleanup Attribute.
     620        /*
     621        std::list< ast::Attribute * > attributes;
     622        {
     623                std::list<  > attr_params;
     624                attr_params.push_back( nameOf( finally_wrapper ) );
     625                attributes.push_back( new Attribute( "cleanup", attr_params ) );
     626        }
     627        */
     628
     629        return new ast::ObjectDecl(
     630                loc,
     631                "__finally_hook",
     632                new ast::StructInstType(
     633                        hook_decl
     634                        ),
     635                nullptr,
     636                ast::Storage::Classes{},
     637                ast::Linkage::Cforall,
     638                nullptr,
     639                {new ast::Attribute("cleanup", {new ast::VariableExpr{loc, finally_wrapper}})}
     640                );
     641}
     642
     643ast::Stmt * TryMutatorCore::create_resume_rethrow( const ast::ThrowStmt *throwStmt ) {
     644        // return false;
     645        const CodeLocation loc = throwStmt->location;
     646        ast::Stmt * result = new ast::ReturnStmt(loc,
     647                ast::ConstantExpr::from_bool( loc, false )
     648                );
     649        result->labels = throwStmt->labels;
     650        // delete throwStmt; done by postvisit
     651        return result;
     652}
     653
     654// Visiting/Mutating Functions
     655void TryMutatorCore::previsit( const ast::StructDecl *structDecl ) {
     656        if ( !structDecl->body ) {
     657                // Skip children?
     658                return;
     659        } else if ( structDecl->name == "__cfaehm_base_exception_t" ) {
     660                assert( nullptr == except_decl );
     661                except_decl = structDecl;
     662                init_func_types();
     663        } else if ( structDecl->name == "__cfaehm_try_resume_node" ) {
     664                assert( nullptr == node_decl );
     665                node_decl = structDecl;
     666        } else if ( structDecl->name == "__cfaehm_cleanup_hook" ) {
     667                assert( nullptr == hook_decl );
     668                hook_decl = structDecl;
     669        }
     670}
     671
     672ast::Stmt * TryMutatorCore::postvisit( const ast::TryStmt *tryStmt ) {
     673        assert( except_decl );
     674        assert( node_decl );
     675        assert( hook_decl );
     676
     677        const CodeLocation loc = tryStmt->location;
     678        ast::TryStmt * mutStmt = mutate(tryStmt);
     679        // Generate a prefix for the function names?
     680
     681        ast::CompoundStmt * block = new ast::CompoundStmt( loc );
     682        // ast::CompoundStmt * inner = take_try_block( mutStmt );
     683        // this is never mutated so let node deletion do its job?
     684        const ast::CompoundStmt * inner = mutStmt->body;
     685
     686        if ( mutStmt->finally ) {
     687                // Define the helper function.
     688                ast::FunctionDecl * finally_block =
     689                        create_finally_wrapper( mutStmt );
     690                appendDeclStmt( block, finally_block );
     691                // Create and add the finally cleanup hook.
     692                appendDeclStmt( block, create_finally_hook( finally_block ) );
     693        }
     694
     695        CatchList termination_handlers;
     696        CatchList resumption_handlers;
     697
     698        for (auto & handler: mutStmt->handlers) {
     699                // xxx - should always be unique? mutate as safe const-cast
     700                assert(handler->unique());
     701                if (handler->kind == ast::ExceptionKind::Resume) {
     702                        resumption_handlers.push_back(handler.get_and_mutate());
     703                }
     704                else {
     705                        termination_handlers.push_back(handler.get_and_mutate());
     706                }
     707        }
     708        // split( mutStmt->handlers,
     709        //              termination_handlers, resumption_handlers );
     710
     711        if ( resumption_handlers.size() ) {
     712                // Define the helper function.
     713                ast::FunctionDecl * resume_handler =
     714                        create_resume_handler( resumption_handlers );
     715                appendDeclStmt( block, resume_handler );
     716                // Prepare hooks
     717                inner = create_resume_wrapper( inner, resume_handler );
     718        }
     719
     720        if ( termination_handlers.size() ) {
     721                // Define the three helper functions.
     722                ast::FunctionDecl * try_wrapper = create_try_wrapper( inner );
     723                appendDeclStmt( block, try_wrapper );
     724                ast::FunctionDecl * terminate_catch =
     725                        create_terminate_catch( termination_handlers );
     726                appendDeclStmt( block, terminate_catch );
     727                ast::FunctionDecl * terminate_match =
     728                        create_terminate_match( termination_handlers );
     729                appendDeclStmt( block, terminate_match );
     730                // Build the call to the try wrapper.
     731                inner = create_terminate_caller(inner->location,
     732                        try_wrapper, terminate_catch, terminate_match );
     733        }
     734
     735        // Embed the try block.
     736        block->push_back( inner );
     737
     738        return block;
     739}
     740
     741ast::Stmt * TryMutatorCore::postvisit( const ast::ThrowStmt *throwStmt ) {
     742        // Only valid `throwResume;` statements should remain. (2/3 checks)
     743        assert( ast::ExceptionKind::Resume == throwStmt->kind && ! throwStmt->expr );
     744        return create_resume_rethrow( throwStmt );
     745}
     746
    130747} // namespace
    131748
    132749void translateThrows( ast::TranslationUnit & transUnit ) {
    133750        ast::Pass<TranslateThrowsCore>::run( transUnit );
     751}
     752
     753void translateTries( ast::TranslationUnit & transUnit ) {
     754        ast::Pass<TryMutatorCore>::run(transUnit);
    134755}
    135756

  • src/ControlStruct/FixLabels.cpp

    r97c215f rf5a51db  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 09:39:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:53:00 2021
    13 // Update Count     : 3
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:19:17 2022
     13// Update Count     : 9
    1414//
    1515
    … …  
    2020#include "AST/Stmt.hpp"
    2121#include "ControlStruct/MultiLevelExit.hpp"
     22using namespace ast;
    2223
    2324namespace ControlStruct {
    24 
    25 namespace {
    26 
    27 class FixLabelsCore final : public ast::WithGuards {
     25class FixLabelsCore final : public WithGuards {
    2826        LabelToStmt labelTable;
    29 public:
     27  public:
    3028        FixLabelsCore() : labelTable() {}
    3129
    32         void previsit( const ast::FunctionDecl * );
    33         const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
    34         void previsit( const ast::Stmt * );
    35         void previsit( const ast::BranchStmt * );
    36         void previsit( const ast::LabelAddressExpr * );
     30        void previsit( const FunctionDecl * );
     31        const FunctionDecl * postvisit( const FunctionDecl * );
     32        void previsit( const Stmt * );
     33        void previsit( const BranchStmt * );
     34        void previsit( const LabelAddressExpr * );
    3735
    38         void setLabelsDef( const std::vector<ast::Label> &, const ast::Stmt * );
    39         void setLabelsUsage( const ast::Label & );
     36        void setLabelsDef( const std::vector<Label> &, const Stmt * );
     37        void setLabelsUsage( const Label & );
    4038};
    4139
    42 void FixLabelsCore::previsit( const ast::FunctionDecl * ) {
     40void FixLabelsCore::previsit( const FunctionDecl * ) {
    4341        GuardValue( labelTable ).clear();
    4442}
    4543
    46 const ast::FunctionDecl * FixLabelsCore::postvisit(
    47                 const ast::FunctionDecl * decl ) {
     44const FunctionDecl * FixLabelsCore::postvisit(
     45        const FunctionDecl * decl ) {
    4846        if ( nullptr == decl->stmts ) return decl;
    4947        for ( auto kvp : labelTable ) {
    5048                if ( nullptr == kvp.second ) {
    5149                        SemanticError( kvp.first.location,
    52                                 "Use of undefined label: " + kvp.first.name );
     50                                                   "Use of undefined label: " + kvp.first.name );
    5351                }
    5452        }
    55         return ast::mutate_field( decl, &ast::FunctionDecl::stmts,
    56                 multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
     53        return mutate_field( decl, &FunctionDecl::stmts,
     54                                                 multiLevelExitUpdate( decl->stmts.get(), labelTable ) );
    5755}
    5856
    59 void FixLabelsCore::previsit( const ast::Stmt * stmt ) {
     57void FixLabelsCore::previsit( const Stmt * stmt ) {
    6058        if ( !stmt->labels.empty() ) {
    6159                setLabelsDef( stmt->labels, stmt );
    … …  
    6361}
    6462
    65 void FixLabelsCore::previsit( const ast::BranchStmt * stmt ) {
     63void FixLabelsCore::previsit( const BranchStmt * stmt ) {
    6664        if ( !stmt->labels.empty() ) {
    6765                setLabelsDef( stmt->labels, stmt );
    … …  
    7270}
    7371
    74 void FixLabelsCore::previsit( const ast::LabelAddressExpr * expr ) {
     72void FixLabelsCore::previsit( const LabelAddressExpr * expr ) {
    7573        assert( !expr->arg.empty() );
    7674        setLabelsUsage( expr->arg );
    … …  
    7876
    7977void FixLabelsCore::setLabelsDef(
    80                 const std::vector<ast::Label> & labels, const ast::Stmt * stmt ) {
     78        const std::vector<Label> & labels, const Stmt * stmt ) {
    8179        assert( !labels.empty() );
    8280        assert( stmt );
    … …  
    8987                        // Duplicate definition, this is an error.
    9088                        SemanticError( label.location,
    91                                 "Duplicate definition of label: " + label.name );
     89                                                   "Duplicate definition of label: " + label.name );
    9290                } else {
    9391                        // Perviously used, but not defined until now.
    … …  
    9896
    9997// Label was used, if it is new add it to the table.
    100 void FixLabelsCore::setLabelsUsage( const ast::Label & label ) {
     98void FixLabelsCore::setLabelsUsage( const Label & label ) {
    10199        if ( labelTable.find( label ) == labelTable.end() ) {
    102100                labelTable[ label ] = nullptr;
    … …  
    104102}
    105103
    106 } // namespace
    107 
    108 void fixLabels( ast::TranslationUnit & translationUnit ) {
    109         ast::Pass<FixLabelsCore>::run( translationUnit );
     104void fixLabels( TranslationUnit & translationUnit ) {
     105        Pass<FixLabelsCore>::run( translationUnit );
    110106}
    111 
    112107} // namespace ControlStruct
    113108

  • src/ControlStruct/FixLabels.hpp

    r97c215f rf5a51db  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 09:36:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  1 09:40:00 2021
    13 // Update Count     : 0
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:18:43 2022
     13// Update Count     : 2
    1414//
    1515
    … …  
    1717
    1818namespace ast {
    19         class TranslationUnit;
     19class TranslationUnit;
    2020}
    2121
    2222namespace ControlStruct {
    23 
    24 /// normalizes label definitions and generates multi-level exit labels
     23// normalizes label definitions and generates multi-level exit labels
    2524void fixLabels( ast::TranslationUnit & translationUnit );
    26 
    2725}
    2826

  • src/ControlStruct/ForExprMutator.cc

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Mon Mar 11 22:26:52 2019
    13 // Update Count     : 14
     12// Last Modified On : Tue Feb  1 09:26:12 2022
     13// Update Count     : 16
    1414//
    1515
    … …  
    4545                return hoist( forStmt, forStmt->initialization );
    4646        }
    47         Statement * ForExprMutator::postmutate( WhileStmt * whileStmt ) {
    48                 return hoist( whileStmt, whileStmt->initialization );
     47        Statement * ForExprMutator::postmutate( WhileDoStmt * whileDoStmt ) {
     48                return hoist( whileDoStmt, whileDoStmt->initialization );
    4949        }
    5050} // namespace ControlStruct

  • src/ControlStruct/ForExprMutator.h

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Aug 17 15:32:48 2017
    13 // Update Count     : 5
     12// Last Modified On : Tue Feb  1 09:18:50 2022
     13// Update Count     : 7
    1414//
    1515
    … …  
    1818class IfStmt;
    1919class ForStmt;
    20 class WhileStmt;
     20class WhileDoStmt;
    2121class Statement;
    2222
    … …  
    2424        class ForExprMutator {
    2525          public:
    26                 Statement *postmutate( IfStmt * );
    27                 Statement *postmutate( ForStmt * );
    28                 Statement *postmutate( WhileStmt * );
     26                Statement * postmutate( IfStmt * );
     27                Statement * postmutate( ForStmt * );
     28                Statement * postmutate( WhileDoStmt * );
    2929        };
    3030} // namespace ControlStruct

  • src/ControlStruct/LabelFixer.cc

    r97c215f rf5a51db  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Jan 21 10:32:00 2020
    13 // Update Count     : 160
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 09:12:09 2022
     13// Update Count     : 162
    1414//
    1515
    … …  
    2727
    2828namespace ControlStruct {
    29         bool LabelFixer::Entry::insideLoop() {
    30                 return ( dynamic_cast< ForStmt * > ( definition ) ||
    31                         dynamic_cast< WhileStmt * > ( definition )  );
     29bool LabelFixer::Entry::insideLoop() {
     30        return ( dynamic_cast< ForStmt * > ( definition ) ||
     31                dynamic_cast< WhileDoStmt * > ( definition )  );
     32}
     33
     34LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
     35        if ( generator == 0 )
     36                generator = LabelGenerator::getGenerator();
     37}
     38
     39void LabelFixer::previsit( FunctionDecl * ) {
     40        // need to go into a nested function in a fresh state
     41        GuardValue( labelTable );
     42        labelTable.clear();
     43}
     44
     45void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
     46        PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
     47        // We start in the body so we can stop when we hit another FunctionDecl.
     48        maybeMutate( functionDecl->statements, mlem );
     49}
     50
     51// prune to at most one label definition for each statement
     52void LabelFixer::previsit( Statement * stmt ) {
     53        std::list< Label > &labels = stmt->get_labels();
     54
     55        if ( ! labels.empty() ) {
     56                // only remember one label for each statement
     57                Label current = setLabelsDef( labels, stmt );
     58        } // if
     59}
     60
     61void LabelFixer::previsit( BranchStmt * branchStmt ) {
     62        previsit( ( Statement *)branchStmt );
     63
     64        // for labeled branches, add an entry to the label table
     65        Label target = branchStmt->get_target();
     66        if ( target != "" ) {
     67                setLabelsUsg( target, branchStmt );
     68        }
     69}
     70
     71void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
     72        Label & target = addrExpr->arg;
     73        assert( target != "" );
     74        setLabelsUsg( target, addrExpr );
     75}
     76
     77
     78// Sets the definition of the labelTable entry to be the provided statement for every label in
     79// the list parameter. Happens for every kind of statement.
     80Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
     81        assert( definition != 0 );
     82        assert( llabel.size() > 0 );
     83
     84        for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
     85                Label & l = *i;
     86                l.set_statement( definition ); // attach statement to the label to be used later
     87                if ( labelTable.find( l ) == labelTable.end() ) {
     88                        // All labels on this statement need to use the same entry,
     89                        // so this should only be created once.
     90                        // undefined and unused until now, add an entry
     91                        labelTable[ l ] = new Entry( definition );
     92                } else if ( labelTable[ l ]->defined() ) {
     93                        // defined twice, error
     94                        SemanticError( l.get_statement()->location,
     95                                "Duplicate definition of label: " + l.get_name() );
     96                } else {
     97                        // used previously, but undefined until now -> link with this entry
     98                        // Question: Is changing objects important?
     99                        delete labelTable[ l ];
     100                        labelTable[ l ] = new Entry( definition );
     101                } // if
     102        } // for
     103
     104        // Produce one of the labels attached to this statement to be temporarily used as the
     105        // canonical label.
     106        return labelTable[ llabel.front() ]->get_label();
     107}
     108
     109// A label was used, add it to the table if it isn't already there
     110template< typename UsageNode >
     111void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
     112        assert( use != 0 );
     113
     114        // add label with an unknown origin
     115        if ( labelTable.find( orgValue ) == labelTable.end() ) {
     116                labelTable[ orgValue ] = new Entry( 0 );
     117        }
     118}
     119
     120// Builds a table that maps a label to its defining statement.
     121std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
     122        std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
     123        for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
     124                if ( ! i->second->defined() ) {
     125                        SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
     126                }
     127                (*ret)[ i->first ] = i->second->get_definition();
    32128        }
    33129
    34         LabelFixer::LabelFixer( LabelGenerator * gen ) : generator ( gen ) {
    35                 if ( generator == 0 )
    36                         generator = LabelGenerator::getGenerator();
    37         }
    38 
    39         void LabelFixer::previsit( FunctionDecl * ) {
    40                 // need to go into a nested function in a fresh state
    41                 GuardValue( labelTable );
    42                 labelTable.clear();
    43         }
    44 
    45         void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
    46                 PassVisitor<MultiLevelExitMutator> mlem( resolveJumps(), generator );
    47                 // We start in the body so we can stop when we hit another FunctionDecl.
    48                 maybeMutate( functionDecl->statements, mlem );
    49         }
    50 
    51         // prune to at most one label definition for each statement
    52         void LabelFixer::previsit( Statement * stmt ) {
    53                 std::list< Label > &labels = stmt->get_labels();
    54 
    55                 if ( ! labels.empty() ) {
    56                         // only remember one label for each statement
    57                         Label current = setLabelsDef( labels, stmt );
    58                 } // if
    59         }
    60 
    61         void LabelFixer::previsit( BranchStmt * branchStmt ) {
    62                 previsit( ( Statement *)branchStmt );
    63 
    64                 // for labeled branches, add an entry to the label table
    65                 Label target = branchStmt->get_target();
    66                 if ( target != "" ) {
    67                         setLabelsUsg( target, branchStmt );
    68                 }
    69         }
    70 
    71         void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
    72                 Label & target = addrExpr->arg;
    73                 assert( target != "" );
    74                 setLabelsUsg( target, addrExpr );
    75         }
    76 
    77 
    78         // Sets the definition of the labelTable entry to be the provided statement for every label in
    79         // the list parameter. Happens for every kind of statement.
    80         Label LabelFixer::setLabelsDef( std::list< Label > & llabel, Statement * definition ) {
    81                 assert( definition != 0 );
    82                 assert( llabel.size() > 0 );
    83 
    84                 for ( std::list< Label >::iterator i = llabel.begin(); i != llabel.end(); i++ ) {
    85                         Label & l = *i;
    86                         l.set_statement( definition ); // attach statement to the label to be used later
    87                         if ( labelTable.find( l ) == labelTable.end() ) {
    88                                 // All labels on this statement need to use the same entry,
    89                                 // so this should only be created once.
    90                                 // undefined and unused until now, add an entry
    91                                 labelTable[ l ] = new Entry( definition );
    92                         } else if ( labelTable[ l ]->defined() ) {
    93                                 // defined twice, error
    94                                 SemanticError( l.get_statement()->location,
    95                                         "Duplicate definition of label: " + l.get_name() );
    96                         } else {
    97                                 // used previously, but undefined until now -> link with this entry
    98                                 // Question: Is changing objects important?
    99                                 delete labelTable[ l ];
    100                                 labelTable[ l ] = new Entry( definition );
    101                         } // if
    102                 } // for
    103 
    104                 // Produce one of the labels attached to this statement to be temporarily used as the
    105                 // canonical label.
    106                 return labelTable[ llabel.front() ]->get_label();
    107         }
    108 
    109         // A label was used, add it to the table if it isn't already there
    110         template< typename UsageNode >
    111         void LabelFixer::setLabelsUsg( Label orgValue, UsageNode *use ) {
    112                 assert( use != 0 );
    113 
    114                 // add label with an unknown origin
    115                 if ( labelTable.find( orgValue ) == labelTable.end() ) {
    116                         labelTable[ orgValue ] = new Entry( 0 );
    117                 }
    118         }
    119 
    120         // Builds a table that maps a label to its defining statement.
    121         std::map<Label, Statement * > * LabelFixer::resolveJumps() throw ( SemanticErrorException ) {
    122                 std::map< Label, Statement * > *ret = new std::map< Label, Statement * >();
    123                 for ( std::map< Label, Entry * >::iterator i = labelTable.begin(); i != labelTable.end(); ++i ) {
    124                         if ( ! i->second->defined() ) {
    125                                 SemanticError( i->first.get_statement()->location, "Use of undefined label: " + i->first.get_name() );
    126                         }
    127                         (*ret)[ i->first ] = i->second->get_definition();
    128                 }
    129 
    130                 return ret;
    131         }
     130        return ret;
     131}
    132132}  // namespace ControlStruct
    133133

  • src/ControlStruct/LabelFixer.h

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jul 22 09:17:24 2017
    13 // Update Count     : 34
     12// Last Modified On : Mon Jan 31 22:28:04 2022
     13// Update Count     : 35
    1414//
    1515
    … …  
    2626
    2727namespace ControlStruct {
    28         /// normalizes label definitions and generates multi-level exit labels
    29         class LabelGenerator;
     28// normalizes label definitions and generates multi-level exit labels
     29class LabelGenerator;
    3030
    31         class LabelFixer final : public WithGuards {
    32           public:
    33                 LabelFixer( LabelGenerator *gen = 0 );
     31class LabelFixer final : public WithGuards {
     32  public:
     33        LabelFixer( LabelGenerator *gen = 0 );
    3434
    35                 std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
     35        std::map < Label, Statement * > *resolveJumps() throw ( SemanticErrorException );
    3636
    37                 // Declarations
    38                 void previsit( FunctionDecl *functionDecl );
    39                 void postvisit( FunctionDecl *functionDecl );
     37        // Declarations
     38        void previsit( FunctionDecl *functionDecl );
     39        void postvisit( FunctionDecl *functionDecl );
    4040
    41                 // Statements
    42                 void previsit( Statement *stmt );
    43                 void previsit( BranchStmt *branchStmt );
     41        // Statements
     42        void previsit( Statement *stmt );
     43        void previsit( BranchStmt *branchStmt );
    4444
    45                 // Expressions
    46                 void previsit( LabelAddressExpr *addrExpr );
     45        // Expressions
     46        void previsit( LabelAddressExpr *addrExpr );
    4747
    48                 Label setLabelsDef( std::list< Label > &, Statement *definition );
    49                 template< typename UsageNode >
    50                 void setLabelsUsg( Label, UsageNode *usage = 0 );
     48        Label setLabelsDef( std::list< Label > &, Statement *definition );
     49        template< typename UsageNode >
     50        void setLabelsUsg( Label, UsageNode *usage = 0 );
     51
     52  private:
     53        class Entry {
     54                public:
     55                Entry( Statement *to ) : definition( to ) {}
     56                bool defined() { return ( definition != 0 ); }
     57                bool insideLoop();
     58
     59                Label get_label() const { return label; }
     60                void set_label( Label lab ) { label = lab; }
     61
     62                Statement *get_definition() const { return definition; }
     63                void set_definition( Statement *def ) { definition = def; }
    5164
    5265          private:
    53                 class Entry {
    54                         public:
    55                         Entry( Statement *to ) : definition( to ) {}
    56                         bool defined() { return ( definition != 0 ); }
    57                         bool insideLoop();
     66                Label label;
     67                Statement *definition;
     68        };
    5869
    59                         Label get_label() const { return label; }
    60                         void set_label( Label lab ) { label = lab; }
    61 
    62                         Statement *get_definition() const { return definition; }
    63                         void set_definition( Statement *def ) { definition = def; }
    64 
    65                   private:
    66                         Label label;
    67                         Statement *definition;
    68                 };
    69 
    70                 std::map < Label, Entry *> labelTable;
    71                 LabelGenerator *generator;
    72         };
     70        std::map < Label, Entry *> labelTable;
     71        LabelGenerator *generator;
     72};
    7373} // namespace ControlStruct
    7474

  • src/ControlStruct/LabelGenerator.cc

    r97c215f rf5a51db  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:18:00 2021
    13 // Update Count     : 17
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:30:26 2022
     13// Update Count     : 28
    1414//
    1515
    … …  
    1717#include <sstream>              // for ostringstream
    1818#include <list>                 // for list
     19using namespace std;
    1920
    2021#include "LabelGenerator.h"
    2122
    22 #include "AST/Attribute.hpp"
    23 #include "AST/Label.hpp"
    24 #include "AST/Stmt.hpp"
    2523#include "SynTree/Attribute.h"  // for Attribute
    2624#include "SynTree/Label.h"      // for Label, operator<<
    … …  
    2826
    2927namespace ControlStruct {
    30 
    3128int LabelGenerator::current = 0;
    3229LabelGenerator * LabelGenerator::labelGenerator = nullptr;
    3330
    34         LabelGenerator * LabelGenerator::getGenerator() {
    35                 if ( LabelGenerator::labelGenerator == 0 )
    36                         LabelGenerator::labelGenerator = new LabelGenerator();
    37                 return labelGenerator;
    38         }
    39 
    40         Label LabelGenerator::newLabel( std::string suffix, Statement * stmt ) {
    41                 std::ostringstream os;
    42                 os << "__L" << current++ << "__" << suffix;
    43                 if ( stmt && ! stmt->get_labels().empty() ) {
    44                         os << "_" << stmt->get_labels().front() << "__";
    45                 } // if
    46                 std::string ret = os.str();
    47                 Label l( ret );
    48                 l.get_attributes().push_back( new Attribute("unused") );
    49                 return l;
    50         }
    51 
    52 ast::Label LabelGenerator::newLabel(
    53                 const std::string & suffix, const ast::Stmt * stmt ) {
    54         assert( stmt );
    55 
    56         std::ostringstream os;
    57         os << "__L" << current++ << "__" << suffix;
    58         if ( stmt && !stmt->labels.empty() ) {
    59                 os << "_" << stmt->labels.front() << "__";
    60         }
    61         ast::Label ret_label( stmt->location, os.str() );
    62         ret_label.attributes.push_back( new ast::Attribute( "unused" ) );
    63         return ret_label;
     31LabelGenerator * LabelGenerator::getGenerator() {
     32        if ( LabelGenerator::labelGenerator == 0 )
     33                LabelGenerator::labelGenerator = new LabelGenerator();
     34        return labelGenerator;
    6435}
    6536
     37Label LabelGenerator::newLabel( string suffix, Statement * stmt ) {
     38        ostringstream os;
     39        os << "__L_OLD" << current++ << "__" << suffix;
     40        if ( stmt && ! stmt->get_labels().empty() ) {
     41                os << "_" << stmt->get_labels().front() << "__";
     42        } // if
     43        string ret = os.str();
     44        Label l( ret );
     45        l.get_attributes().push_back( new Attribute( "unused" ) );
     46        return l;
     47}
    6648} // namespace ControlStruct
    6749
    6850// Local Variables: //
    69 // tab-width: 4 //
    7051// mode: c++ //
    71 // compile-command: "make install" //
    7252// End: //

  • src/ControlStruct/LabelGenerator.h

    r97c215f rf5a51db  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:16:00 2021
    13 // Update Count     : 8
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:30:10 2022
     13// Update Count     : 16
    1414//
    1515
    … …  
    2121
    2222class Statement;
     23
    2324namespace ast {
    24         class Stmt;
    25         class Label;
     25class Stmt;
     26class Label;
    2627}
    2728
    2829namespace ControlStruct {
    29 
    3030class LabelGenerator {
    3131        static int current;
    3232        static LabelGenerator *labelGenerator;
    33 protected:
     33  protected:
    3434        LabelGenerator() {}
    35 public:
     35  public:
    3636        static LabelGenerator *getGenerator();
    3737        static Label newLabel(std::string suffix, Statement * stmt = nullptr);
    38         static ast::Label newLabel( const std::string&, const ast::Stmt * );
    39         static void reset() { current = 0; }
    40         static void rewind() { current--; }
    4138};
    42 
    4339} // namespace ControlStruct
    4440

  • src/ControlStruct/MLEMutator.cc

    r97c215f rf5a51db  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jan 22 11:50:00 2020
    13 // Update Count     : 223
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Feb  2 20:18:57 2022
     13// Update Count     : 227
    1414//
    1515
    … …  
    3939        namespace {
    4040                bool isLoop( const MultiLevelExitMutator::Entry & e ) {
    41                         return dynamic_cast< WhileStmt * >( e.get_controlStructure() )
     41                        return dynamic_cast< WhileDoStmt * >( e.get_controlStructure() )
    4242                                || dynamic_cast< ForStmt * >( e.get_controlStructure() );
    4343                }
    … …  
    136136                        }
    137137                }
    138                 assertf( false, "Could not find label '%s' on statement %s",
     138                assertf( false, "CFA internal error: could not find label '%s' on statement %s",
    139139                        originalTarget.get_name().c_str(), toString( stmt ).c_str() );
    140140        }
    … …  
    295295        }
    296296
    297         void MultiLevelExitMutator::premutate( WhileStmt * whileStmt ) {
    298                 return prehandleLoopStmt( whileStmt );
     297        void MultiLevelExitMutator::premutate( WhileDoStmt * whileDoStmt ) {
     298                return prehandleLoopStmt( whileDoStmt );
    299299        }
    300300
    … …  
    303303        }
    304304
    305         Statement * MultiLevelExitMutator::postmutate( WhileStmt * whileStmt ) {
    306                 return posthandleLoopStmt( whileStmt );
     305        Statement * MultiLevelExitMutator::postmutate( WhileDoStmt * whileDoStmt ) {
     306                return posthandleLoopStmt( whileDoStmt );
    307307        }
    308308
    … …  
    395395                }
    396396                assert( ! enclosingControlStructures.empty() );
    397                 assertf( dynamic_cast<SwitchStmt *>( enclosingControlStructures.back().get_controlStructure() ), "Control structure enclosing a case clause must be a switch, but is: %s", toCString( enclosingControlStructures.back().get_controlStructure() ) );
     397                assertf( dynamic_cast<SwitchStmt *>( enclosingControlStructures.back().get_controlStructure() ),
     398                                 "CFA internal error: control structure enclosing a case clause must be a switch, but is: %s",
     399                                 toCString( enclosingControlStructures.back().get_controlStructure() ) );
    398400                if ( caseStmt->isDefault() ) {
    399401                        if ( enclosingControlStructures.back().isFallDefaultUsed() ) {

  • src/ControlStruct/MLEMutator.h

    r97c215f rf5a51db  
    99// Author           : Rodolfo G. Esteves
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Wed Jan 22 11:50:00 2020
    13 // Update Count     : 48
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 09:27:24 2022
     13// Update Count     : 50
    1414//
    1515
    … …  
    4242                void premutate( CompoundStmt *cmpndStmt );
    4343                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticErrorException );
    44                 void premutate( WhileStmt *whileStmt );
    45                 Statement * postmutate( WhileStmt *whileStmt );
     44                void premutate( WhileDoStmt *whileDoStmt );
     45                Statement * postmutate( WhileDoStmt *whileDoStmt );
    4646                void premutate( ForStmt *forStmt );
    4747                Statement * postmutate( ForStmt *forStmt );
    … …  
    6767                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
    6868
    69                         explicit Entry( WhileStmt *stmt, Label breakExit, Label contExit ) :
     69                        explicit Entry( WhileDoStmt *stmt, Label breakExit, Label contExit ) :
    7070                                stmt( stmt ), breakExit( breakExit ), contExit( contExit ) {}
    7171

  • src/ControlStruct/MultiLevelExit.cpp

    r97c215f rf5a51db  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 13:48:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:56:00 2021
    13 // Update Count     : 2
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Feb  2 23:07:54 2022
     13// Update Count     : 33
    1414//
    1515
    … …  
    1818#include "AST/Pass.hpp"
    1919#include "AST/Stmt.hpp"
    20 #include "ControlStruct/LabelGenerator.h"
     20#include "LabelGeneratorNew.hpp"
    2121
    2222#include <set>
     23using namespace std;
     24using namespace ast;
    2325
    2426namespace ControlStruct {
    25 
    26 namespace {
    27 
    2827class Entry {
    29 public:
    30         const ast::Stmt * stmt;
    31 private:
     28  public:
     29        const Stmt * stmt;
     30  private:
    3231        // Organized like a manual ADT. Avoids creating a bunch of dead data.
    3332        struct Target {
    34                 ast::Label label;
     33                Label label;
    3534                bool used = false;
    36                 Target( const ast::Label & label ) : label( label ) {}
     35                Target( const Label & label ) : label( label ) {}
    3736                Target() : label( CodeLocation() ) {}
    3837        };
    … …  
    4140
    4241        enum Kind {
    43                 ForStmt, WhileStmt, CompoundStmt, IfStmt, CaseStmt, SwitchStmt, TryStmt
     42                ForStmtK, WhileDoStmtK, CompoundStmtK, IfStmtK, CaseStmtK, SwitchStmtK, TryStmtK
    4443        } kind;
    4544
    4645        bool fallDefaultValid = true;
    4746
    48         static ast::Label & useTarget( Target & target ) {
     47        static Label & useTarget( Target & target ) {
    4948                target.used = true;
    5049                return target.label;
    5150        }
    52 
    53 public:
    54         Entry( const ast::ForStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
    55                 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmt ) {}
    56         Entry( const ast::WhileStmt * stmt, ast::Label breakExit, ast::Label contExit ) :
    57                 stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileStmt ) {}
    58         Entry( const ast::CompoundStmt *stmt, ast::Label breakExit ) :
    59                 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmt ) {}
    60         Entry( const ast::IfStmt *stmt, ast::Label breakExit ) :
    61                 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmt ) {}
    62         Entry( const ast::CaseStmt *stmt, ast::Label fallExit ) :
    63                 stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmt ) {}
    64         Entry( const ast::SwitchStmt *stmt, ast::Label breakExit, ast::Label fallDefaultExit ) :
    65                 stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmt ) {}
    66         Entry( const ast::TryStmt *stmt, ast::Label breakExit ) :
    67                 stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmt ) {}
    68 
    69         bool isContTarget() const { return kind <= WhileStmt; }
    70         bool isBreakTarget() const { return CaseStmt != kind; }
    71         bool isFallTarget() const { return CaseStmt == kind; }
    72         bool isFallDefaultTarget() const { return SwitchStmt == kind; }
    73 
    74         ast::Label useContExit() { assert( kind <= WhileStmt ); return useTarget(secondTarget); }
    75         ast::Label useBreakExit() { assert( CaseStmt != kind ); return useTarget(firstTarget); }
    76         ast::Label useFallExit() { assert( CaseStmt == kind );  return useTarget(firstTarget); }
    77         ast::Label useFallDefaultExit() { assert( SwitchStmt == kind ); return useTarget(secondTarget); }
    78 
    79         bool isContUsed() const { assert( kind <= WhileStmt ); return secondTarget.used; }
    80         bool isBreakUsed() const { assert( CaseStmt != kind ); return firstTarget.used; }
    81         bool isFallUsed() const { assert( CaseStmt == kind ); return firstTarget.used; }
    82         bool isFallDefaultUsed() const { assert( SwitchStmt == kind ); return secondTarget.used; }
     51  public:
     52        Entry( const ForStmt * stmt, Label breakExit, Label contExit ) :
     53                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( ForStmtK ) {}
     54        Entry( const WhileDoStmt * stmt, Label breakExit, Label contExit ) :
     55                stmt( stmt ), firstTarget( breakExit ), secondTarget( contExit ), kind( WhileDoStmtK ) {}
     56        Entry( const CompoundStmt *stmt, Label breakExit ) :
     57                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( CompoundStmtK ) {}
     58        Entry( const IfStmt *stmt, Label breakExit ) :
     59                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( IfStmtK ) {}
     60        Entry( const CaseStmt *stmt, Label fallExit ) :
     61                stmt( stmt ), firstTarget( fallExit ), secondTarget(), kind( CaseStmtK ) {}
     62        Entry( const SwitchStmt *stmt, Label breakExit, Label fallDefaultExit ) :
     63                stmt( stmt ), firstTarget( breakExit ), secondTarget( fallDefaultExit ), kind( SwitchStmtK ) {}
     64        Entry( const TryStmt *stmt, Label breakExit ) :
     65                stmt( stmt ), firstTarget( breakExit ), secondTarget(), kind( TryStmtK ) {}
     66
     67        bool isContTarget() const { return kind <= WhileDoStmtK; }
     68        bool isBreakTarget() const { return kind != CaseStmtK; }
     69        bool isFallTarget() const { return kind == CaseStmtK; }
     70        bool isFallDefaultTarget() const { return kind == SwitchStmtK; }
     71
     72        // These routines set a target as being "used" by a BranchStmt
     73        Label useContExit() { assert( kind <= WhileDoStmtK ); return useTarget(secondTarget); }
     74        Label useBreakExit() { assert( kind != CaseStmtK ); return useTarget(firstTarget); }
     75        Label useFallExit() { assert( kind == CaseStmtK );  return useTarget(firstTarget); }
     76        Label useFallDefaultExit() { assert( kind == SwitchStmtK ); return useTarget(secondTarget); }
     77
     78        // These routines check if a specific label for a statement is used by a BranchStmt
     79        bool isContUsed() const { assert( kind <= WhileDoStmtK ); return secondTarget.used; }
     80        bool isBreakUsed() const { assert( kind != CaseStmtK ); return firstTarget.used; }
     81        bool isFallUsed() const { assert( kind == CaseStmtK ); return firstTarget.used; }
     82        bool isFallDefaultUsed() const { assert( kind == SwitchStmtK ); return secondTarget.used; }
    8383        void seenDefault() { fallDefaultValid = false; }
    8484        bool isFallDefaultValid() const { return fallDefaultValid; }
    8585};
    8686
    87 // Helper predicates used in std::find_if calls (it doesn't take methods):
     87// Helper predicates used in find_if calls (it doesn't take methods):
    8888bool isBreakTarget( const Entry & entry ) {
    8989        return entry.isBreakTarget();
    … …  
    103103
    104104struct MultiLevelExitCore final :
    105                 public ast::WithVisitorRef<MultiLevelExitCore>,
    106                 public ast::WithShortCircuiting, public ast::WithGuards {
     105        public WithVisitorRef<MultiLevelExitCore>,
     106        public WithShortCircuiting, public WithGuards {
    107107        MultiLevelExitCore( const LabelToStmt & lt );
    108108
    109         void previsit( const ast::FunctionDecl * );
    110 
    111         const ast::CompoundStmt * previsit( const ast::CompoundStmt * );
    112         const ast::BranchStmt * postvisit( const ast::BranchStmt * );
    113         void previsit( const ast::WhileStmt * );
    114         const ast::WhileStmt * postvisit( const ast::WhileStmt * );
    115         void previsit( const ast::ForStmt * );
    116         const ast::ForStmt * postvisit( const ast::ForStmt * );
    117         const ast::CaseStmt * previsit( const ast::CaseStmt * );
    118         void previsit( const ast::IfStmt * );
    119         const ast::IfStmt * postvisit( const ast::IfStmt * );
    120         void previsit( const ast::SwitchStmt * );
    121         const ast::SwitchStmt * postvisit( const ast::SwitchStmt * );
    122         void previsit( const ast::ReturnStmt * );
    123         void previsit( const ast::TryStmt * );
    124         void postvisit( const ast::TryStmt * );
    125         void previsit( const ast::FinallyStmt * );
    126 
    127         const ast::Stmt * mutateLoop( const ast::Stmt * body, Entry& );
     109        void previsit( const FunctionDecl * );
     110
     111        const CompoundStmt * previsit( const CompoundStmt * );
     112        const BranchStmt * postvisit( const BranchStmt * );
     113        void previsit( const WhileDoStmt * );
     114        const WhileDoStmt * postvisit( const WhileDoStmt * );
     115        void previsit( const ForStmt * );
     116        const ForStmt * postvisit( const ForStmt * );
     117        const CaseStmt * previsit( const CaseStmt * );
     118        void previsit( const IfStmt * );
     119        const IfStmt * postvisit( const IfStmt * );
     120        void previsit( const SwitchStmt * );
     121        const SwitchStmt * postvisit( const SwitchStmt * );
     122        void previsit( const ReturnStmt * );
     123        void previsit( const TryStmt * );
     124        void postvisit( const TryStmt * );
     125        void previsit( const FinallyStmt * );
     126
     127        const Stmt * mutateLoop( const Stmt * body, Entry& );
    128128
    129129        const LabelToStmt & target_table;
    130         std::set<ast::Label> fallthrough_labels;
    131         std::vector<Entry> enclosing_control_structures;
    132         ast::Label break_label;
     130        set<Label> fallthrough_labels;
     131        vector<Entry> enclosing_control_structures;
     132        Label break_label;
    133133        bool inFinally;
    134134
    … …  
    138138        const LoopNode * posthandleLoopStmt( const LoopNode * loopStmt );
    139139
    140         std::list<ast::ptr<ast::Stmt>> fixBlock(
    141                 const std::list<ast::ptr<ast::Stmt>> & kids, bool caseClause );
     140        list<ptr<Stmt>> fixBlock(
     141                const list<ptr<Stmt>> & kids, bool caseClause );
    142142
    143143        template<typename UnaryPredicate>
    144144        auto findEnclosingControlStructure( UnaryPredicate pred ) {
    145                 return std::find_if( enclosing_control_structures.rbegin(),
    146                         enclosing_control_structures.rend(), pred );
     145                return find_if( enclosing_control_structures.rbegin(),
     146                                                enclosing_control_structures.rend(), pred );
    147147        }
    148148};
    149149
    150 ast::NullStmt * labelledNullStmt(
    151                 const CodeLocation & cl, const ast::Label & label ) {
    152         return new ast::NullStmt( cl, std::vector<ast::Label>{ label } );
     150NullStmt * labelledNullStmt(
     151        const CodeLocation & cl, const Label & label ) {
     152        return new NullStmt( cl, vector<Label>{ label } );
    153153}
    154154
    … …  
    158158{}
    159159
    160 void MultiLevelExitCore::previsit( const ast::FunctionDecl * ) {
     160void MultiLevelExitCore::previsit( const FunctionDecl * ) {
    161161        visit_children = false;
    162162}
    163163
    164 const ast::CompoundStmt * MultiLevelExitCore::previsit(
    165                 const ast::CompoundStmt * stmt ) {
     164const CompoundStmt * MultiLevelExitCore::previsit(
     165        const CompoundStmt * stmt ) {
    166166        visit_children = false;
    167         bool isLabeled = !stmt->labels.empty();
     167
     168        // if the stmt is labelled then generate a label to check in postvisit if the label is used
     169        bool isLabeled = ! stmt->labels.empty();
    168170        if ( isLabeled ) {
    169                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     171                Label breakLabel = newLabel( "blockBreak", stmt );
    170172                enclosing_control_structures.emplace_back( stmt, breakLabel );
    171173                GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
    172174        }
    173175
    174         auto mutStmt = ast::mutate( stmt );
     176        auto mutStmt = mutate( stmt );
    175177        // A child statement may set the break label.
    176         mutStmt->kids = std::move( fixBlock( stmt->kids, false ) );
     178        mutStmt->kids = move( fixBlock( stmt->kids, false ) );
    177179
    178180        if ( isLabeled ) {
    179                 assert( !enclosing_control_structures.empty() );
     181                assert( ! enclosing_control_structures.empty() );
    180182                Entry & entry = enclosing_control_structures.back();
    181                 if ( !entry.useBreakExit().empty() ) {
     183                if ( ! entry.useBreakExit().empty() ) {
    182184                        break_label = entry.useBreakExit();
    183185                }
    … …  
    187189
    188190size_t getUnusedIndex(
    189                 const ast::Stmt * stmt, const ast::Label & originalTarget ) {
     191        const Stmt * stmt, const Label & originalTarget ) {
    190192        const size_t size = stmt->labels.size();
    191193
    192         // If the label is empty, we can skip adding the unused attribute:
    193         if ( originalTarget.empty() ) return size;
     194        // If the label is empty, do not add unused attribute.
     195  if ( originalTarget.empty() ) return size;
    194196
    195197        // Search for a label that matches the originalTarget.
    196198        for ( size_t i = 0 ; i < size ; ++i ) {
    197                 const ast::Label & label = stmt->labels[i];
     199                const Label & label = stmt->labels[i];
    198200                if ( label == originalTarget ) {
    199                         for ( const ast::Attribute * attr : label.attributes ) {
     201                        for ( const Attribute * attr : label.attributes ) {
    200202                                if ( attr->name == "unused" ) return size;
    201203                        }
    … …  
    203205                }
    204206        }
    205         assertf( false, "Could not find label '%s' on statement %s",
    206                 originalTarget.name.c_str(), toString( stmt ).c_str() );
    207 }
    208 
    209 const ast::Stmt * addUnused(
    210                 const ast::Stmt * stmt, const ast::Label & originalTarget ) {
     207        assertf( false, "CFA internal error: could not find label '%s' on statement %s",
     208                         originalTarget.name.c_str(), toString( stmt ).c_str() );
     209}
     210
     211const Stmt * addUnused(
     212        const Stmt * stmt, const Label & originalTarget ) {
    211213        size_t i = getUnusedIndex( stmt, originalTarget );
    212214        if ( i == stmt->labels.size() ) {
    213215                return stmt;
    214216        }
    215         ast::Stmt * mutStmt = ast::mutate( stmt );
    216         mutStmt->labels[i].attributes.push_back( new ast::Attribute( "unused" ) );
     217        Stmt * mutStmt = mutate( stmt );
     218        mutStmt->labels[i].attributes.push_back( new Attribute( "unused" ) );
    217219        return mutStmt;
    218220}
    219221
    220 const ast::BranchStmt * MultiLevelExitCore::postvisit( const ast::BranchStmt * stmt ) {
    221         std::vector<Entry>::reverse_iterator targetEntry =
     222// This routine updates targets on enclosing control structures to indicate which
     223//     label is used by the BranchStmt that is passed
     224const BranchStmt * MultiLevelExitCore::postvisit( const BranchStmt * stmt ) {
     225        vector<Entry>::reverse_iterator targetEntry =
    222226                enclosing_control_structures.rend();
     227
     228        // Labels on different stmts require different approaches to access
    223229        switch ( stmt->kind ) {
    224         case ast::BranchStmt::Goto:
     230          case BranchStmt::Goto:
    225231                return stmt;
    226         case ast::BranchStmt::Continue:
    227         case ast::BranchStmt::Break: {
    228                 bool isContinue = stmt->kind == ast::BranchStmt::Continue;
    229                 // Handle unlabeled break and continue.
    230                 if ( stmt->target.empty() ) {
    231                         if ( isContinue ) {
    232                                 targetEntry = findEnclosingControlStructure( isContinueTarget );
    233                         } else {
    234                                 if ( enclosing_control_structures.empty() ) {
    235                                         SemanticError( stmt->location,
    236                                                 "'break' outside a loop, 'switch', or labelled block" );
    237                                 }
    238                                 targetEntry = findEnclosingControlStructure( isBreakTarget );
    239                         }
    240                 // Handle labeled break and continue.
    241                 } else {
    242                         // Lookup label in table to find attached control structure.
    243                         targetEntry = findEnclosingControlStructure(
    244                                 [ targetStmt = target_table.at(stmt->target) ](auto entry){
    245                                         return entry.stmt == targetStmt;
    246                                 } );
    247                 }
    248                 // Ensure that selected target is valid.
    249                 if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && !isContinueTarget( *targetEntry ) ) ) {
    250                         SemanticError(
    251                                 stmt->location,
    252                                 toString( (isContinue ? "'continue'" : "'break'"),
    253                                         " target must be an enclosing ",
    254                                         (isContinue ? "loop: " : "control structure: "),
    255                                         stmt->originalTarget ) );
    256                 }
    257                 break;
    258         }
    259         case ast::BranchStmt::FallThrough: {
    260                 targetEntry = findEnclosingControlStructure( isFallthroughTarget );
    261                 // Check that target is valid.
    262                 if ( targetEntry == enclosing_control_structures.rend() ) {
    263                         SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
    264                 }
    265                 if ( !stmt->target.empty() ) {
    266                         // Labelled fallthrough: target must be a valid fallthough label.
    267                         if ( !fallthrough_labels.count( stmt->target ) ) {
    268                                 SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ", stmt->originalTarget ) );
    269                         }
    270                         return new ast::BranchStmt(
    271                                 stmt->location, ast::BranchStmt::Goto, stmt->originalTarget );
    272                 }
    273                 break;
    274         }
    275         case ast::BranchStmt::FallThroughDefault: {
    276                 targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
    277 
    278                 // Check that this is in a switch or choose statement.
    279                 if ( targetEntry == enclosing_control_structures.rend() ) {
    280                         SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
    281                 }
    282 
    283                 // Check that the switch or choose has a default clause.
    284                 auto switchStmt = strict_dynamic_cast< const ast::SwitchStmt * >(
    285                         targetEntry->stmt );
    286                 bool foundDefault = false;
    287                 for ( auto subStmt : switchStmt->stmts ) {
    288                         const ast::CaseStmt * caseStmt = subStmt.strict_as<ast::CaseStmt>();
    289                         if ( caseStmt->isDefault() ) {
    290                                 foundDefault = true;
    291                                 break;
    292                         }
    293                 }
    294                 if ( !foundDefault ) {
    295                         SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose' control structure with a 'default' clause" );
    296                 }
    297                 break;
    298         }
    299         default:
     232          case BranchStmt::Continue:
     233          case BranchStmt::Break: {
     234                  bool isContinue = stmt->kind == BranchStmt::Continue;
     235                  // Handle unlabeled break and continue.
     236                  if ( stmt->target.empty() ) {
     237                          if ( isContinue ) {
     238                                  targetEntry = findEnclosingControlStructure( isContinueTarget );
     239                          } else {
     240                                  if ( enclosing_control_structures.empty() ) {
     241                                          SemanticError( stmt->location,
     242                                                                         "'break' outside a loop, 'switch', or labelled block" );
     243                                  }
     244                                  targetEntry = findEnclosingControlStructure( isBreakTarget );
     245                          }
     246                          // Handle labeled break and continue.
     247                  } else {
     248                          // Lookup label in table to find attached control structure.
     249                          targetEntry = findEnclosingControlStructure(
     250                                  [ targetStmt = target_table.at(stmt->target) ](auto entry){
     251                                          return entry.stmt == targetStmt;
     252                                  } );
     253                  }
     254                  // Ensure that selected target is valid.
     255                  if ( targetEntry == enclosing_control_structures.rend() || ( isContinue && ! isContinueTarget( *targetEntry ) ) ) {
     256                          SemanticError( stmt->location, toString( (isContinue ? "'continue'" : "'break'"),
     257                                                        " target must be an enclosing ", (isContinue ? "loop: " : "control structure: "),
     258                                                        stmt->originalTarget ) );
     259                  }
     260                  break;
     261          }
     262          // handle fallthrough in case/switch stmts
     263          case BranchStmt::FallThrough: {
     264                  targetEntry = findEnclosingControlStructure( isFallthroughTarget );
     265                  // Check that target is valid.
     266                  if ( targetEntry == enclosing_control_structures.rend() ) {
     267                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     268                  }
     269                  if ( ! stmt->target.empty() ) {
     270                          // Labelled fallthrough: target must be a valid fallthough label.
     271                          if ( ! fallthrough_labels.count( stmt->target ) ) {
     272                                  SemanticError( stmt->location, toString( "'fallthrough' target must be a later case statement: ",
     273                                                                                                                   stmt->originalTarget ) );
     274                          }
     275                          return new BranchStmt( stmt->location, BranchStmt::Goto, stmt->originalTarget );
     276                  }
     277                  break;
     278          }
     279          case BranchStmt::FallThroughDefault: {
     280                  targetEntry = findEnclosingControlStructure( isFallthroughDefaultTarget );
     281
     282                  // Check if in switch or choose statement.
     283                  if ( targetEntry == enclosing_control_structures.rend() ) {
     284                          SemanticError( stmt->location, "'fallthrough' must be enclosed in a 'switch' or 'choose'" );
     285                  }
     286
     287                  // Check if switch or choose has default clause.
     288                  auto switchStmt = strict_dynamic_cast< const SwitchStmt * >( targetEntry->stmt );
     289                  bool foundDefault = false;
     290                  for ( auto subStmt : switchStmt->stmts ) {
     291                          const CaseStmt * caseStmt = subStmt.strict_as<CaseStmt>();
     292                          if ( caseStmt->isDefault() ) {
     293                                  foundDefault = true;
     294                                  break;
     295                          }
     296                  }
     297                  if ( ! foundDefault ) {
     298                          SemanticError( stmt->location, "'fallthrough default' must be enclosed in a 'switch' or 'choose'"
     299                                                         "control structure with a 'default' clause" );
     300                  }
     301                  break;
     302          }
     303          default:
    300304                assert( false );
    301305        }
    302306
    303         // Branch error checks: get the appropriate label name:
    304         // (This label will always be replaced.)
    305         ast::Label exitLabel( CodeLocation(), "" );
     307        // Branch error checks: get the appropriate label name, which is always replaced.
     308        Label exitLabel( CodeLocation(), "" );
    306309        switch ( stmt->kind ) {
    307         case ast::BranchStmt::Break:
    308                 assert( !targetEntry->useBreakExit().empty() );
     310          case BranchStmt::Break:
     311                assert( ! targetEntry->useBreakExit().empty() );
    309312                exitLabel = targetEntry->useBreakExit();
    310313                break;
    311         case ast::BranchStmt::Continue:
    312                 assert( !targetEntry->useContExit().empty() );
     314          case BranchStmt::Continue:
     315                assert( ! targetEntry->useContExit().empty() );
    313316                exitLabel = targetEntry->useContExit();
    314317                break;
    315         case ast::BranchStmt::FallThrough:
    316                 assert( !targetEntry->useFallExit().empty() );
     318          case BranchStmt::FallThrough:
     319                assert( ! targetEntry->useFallExit().empty() );
    317320                exitLabel = targetEntry->useFallExit();
    318321                break;
    319         case ast::BranchStmt::FallThroughDefault:
    320                 assert( !targetEntry->useFallDefaultExit().empty() );
     322          case BranchStmt::FallThroughDefault:
     323                assert( ! targetEntry->useFallDefaultExit().empty() );
    321324                exitLabel = targetEntry->useFallDefaultExit();
    322325                // Check that fallthrough default comes before the default clause.
    323                 if ( !targetEntry->isFallDefaultValid() ) {
    324                         SemanticError( stmt->location,
    325                                 "'fallthrough default' must precede the 'default' clause" );
     326                if ( ! targetEntry->isFallDefaultValid() ) {
     327                        SemanticError( stmt->location, "'fallthrough default' must precede the 'default' clause" );
    326328                }
    327329                break;
    328         default:
     330          default:
    329331                assert(0);
    330332        }
    … …  
    333335        targetEntry->stmt = addUnused( targetEntry->stmt, stmt->originalTarget );
    334336
    335         // Replace this with a goto to make later passes more uniform.
    336         return new ast::BranchStmt( stmt->location, ast::BranchStmt::Goto, exitLabel );
    337 }
    338 
    339 void MultiLevelExitCore::previsit( const ast::WhileStmt * stmt ) {
     337        // Replace with goto to make later passes more uniform.
     338        return new BranchStmt( stmt->location, BranchStmt::Goto, exitLabel );
     339}
     340
     341void MultiLevelExitCore::previsit( const WhileDoStmt * stmt ) {
    340342        return prehandleLoopStmt( stmt );
    341343}
    342344
    343 const ast::WhileStmt * MultiLevelExitCore::postvisit( const ast::WhileStmt * stmt ) {
     345const WhileDoStmt * MultiLevelExitCore::postvisit( const WhileDoStmt * stmt ) {
    344346        return posthandleLoopStmt( stmt );
    345347}
    346348
    347 void MultiLevelExitCore::previsit( const ast::ForStmt * stmt ) {
     349void MultiLevelExitCore::previsit( const ForStmt * stmt ) {
    348350        return prehandleLoopStmt( stmt );
    349351}
    350352
    351 const ast::ForStmt * MultiLevelExitCore::postvisit( const ast::ForStmt * stmt ) {
     353const ForStmt * MultiLevelExitCore::postvisit( const ForStmt * stmt ) {
    352354        return posthandleLoopStmt( stmt );
    353355}
    … …  
    355357// Mimic what the built-in push_front would do anyways. It is O(n).
    356358void push_front(
    357                 std::vector<ast::ptr<ast::Stmt>> & vec, const ast::Stmt * element ) {
     359        vector<ptr<Stmt>> & vec, const Stmt * element ) {
    358360        vec.emplace_back( nullptr );
    359361        for ( size_t i = vec.size() - 1 ; 0 < i ; --i ) {
    360                 vec[ i ] = std::move( vec[ i - 1 ] );
     362                vec[ i ] = move( vec[ i - 1 ] );
    361363        }
    362364        vec[ 0 ] = element;
    363365}
    364366
    365 const ast::CaseStmt * MultiLevelExitCore::previsit( const ast::CaseStmt * stmt ) {
     367const CaseStmt * MultiLevelExitCore::previsit( const CaseStmt * stmt ) {
    366368        visit_children = false;
    367369
    368         // If it is the default, mark the default as seen.
     370        // If default, mark seen.
    369371        if ( stmt->isDefault() ) {
    370                 assert( !enclosing_control_structures.empty() );
     372                assert( ! enclosing_control_structures.empty() );
    371373                enclosing_control_structures.back().seenDefault();
    372374        }
    373375
    374376        // The cond may not exist, but if it does update it now.
    375         visitor->maybe_accept( stmt, &ast::CaseStmt::cond );
     377        visitor->maybe_accept( stmt, &CaseStmt::cond );
    376378
    377379        // Just save the mutated node for simplicity.
    378         ast::CaseStmt * mutStmt = ast::mutate( stmt );
    379 
    380         ast::Label fallLabel = LabelGenerator::newLabel( "fallThrough", stmt );
    381         if ( !mutStmt->stmts.empty() ) {
     380        CaseStmt * mutStmt = mutate( stmt );
     381
     382        Label fallLabel = newLabel( "fallThrough", stmt );
     383        if ( ! mutStmt->stmts.empty() ) {
    382384                // Ensure that the stack isn't corrupted by exceptions in fixBlock.
    383385                auto guard = makeFuncGuard(
    384386                        [&](){ enclosing_control_structures.emplace_back( mutStmt, fallLabel ); },
    385387                        [this](){ enclosing_control_structures.pop_back(); }
    386                 );
     388                        );
    387389
    388390                // These should already be in a block.
    389                 auto block = ast::mutate( mutStmt->stmts.front().strict_as<ast::CompoundStmt>() );
     391                auto block = mutate( mutStmt->stmts.front().strict_as<CompoundStmt>() );
    390392                block->kids = fixBlock( block->kids, true );
    391393
    392394                // Add fallthrough label if necessary.
    393                 assert( !enclosing_control_structures.empty() );
     395                assert( ! enclosing_control_structures.empty() );
    394396                Entry & entry = enclosing_control_structures.back();
    395397                if ( entry.isFallUsed() ) {
    396                         mutStmt->stmts.push_back(
    397                                 labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
    398                 }
    399         }
    400         assert( !enclosing_control_structures.empty() );
     398                        mutStmt->stmts.push_back( labelledNullStmt( mutStmt->location, entry.useFallExit() ) );
     399                }
     400        }
     401        assert( ! enclosing_control_structures.empty() );
    401402        Entry & entry = enclosing_control_structures.back();
    402         assertf( dynamic_cast< const ast::SwitchStmt * >( entry.stmt ),
    403                 "Control structure enclosing a case clause must be a switch, but is: %s",
    404                 toString( entry.stmt ).c_str() );
     403        assertf( dynamic_cast< const SwitchStmt * >( entry.stmt ),
     404                         "CFA internal error: control structure enclosing a case clause must be a switch, but is: %s",
     405                         toString( entry.stmt ).c_str() );
    405406        if ( mutStmt->isDefault() ) {
    406407                if ( entry.isFallDefaultUsed() ) {
    407408                        // Add fallthrough default label if necessary.
    408                         push_front( mutStmt->stmts, labelledNullStmt(
    409                                 stmt->location, entry.useFallDefaultExit()
    410                         ) );
     409                        push_front( mutStmt->stmts, labelledNullStmt( stmt->location, entry.useFallDefaultExit() ) );
    411410                }
    412411        }
    … …  
    414413}
    415414
    416 void MultiLevelExitCore::previsit( const ast::IfStmt * stmt ) {
    417         bool labeledBlock = !stmt->labels.empty();
     415void MultiLevelExitCore::previsit( const IfStmt * stmt ) {
     416        bool labeledBlock = ! stmt->labels.empty();
    418417        if ( labeledBlock ) {
    419                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     418                Label breakLabel = newLabel( "blockBreak", stmt );
    420419                enclosing_control_structures.emplace_back( stmt, breakLabel );
    421420                GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
    … …  
    423422}
    424423
    425 const ast::IfStmt * MultiLevelExitCore::postvisit( const ast::IfStmt * stmt ) {
    426         bool labeledBlock = !stmt->labels.empty();
     424const IfStmt * MultiLevelExitCore::postvisit( const IfStmt * stmt ) {
     425        bool labeledBlock = ! stmt->labels.empty();
    427426        if ( labeledBlock ) {
    428427                auto this_label = enclosing_control_structures.back().useBreakExit();
    429                 if ( !this_label.empty() ) {
     428                if ( ! this_label.empty() ) {
    430429                        break_label = this_label;
    431430                }
    … …  
    434433}
    435434
    436 bool isDefaultCase( const ast::ptr<ast::Stmt> & stmt ) {
    437         const ast::CaseStmt * caseStmt = stmt.strict_as<ast::CaseStmt>();
     435bool isDefaultCase( const ptr<Stmt> & stmt ) {
     436        const CaseStmt * caseStmt = stmt.strict_as<CaseStmt>();
    438437        return caseStmt->isDefault();
    439438}
    440439
    441 void MultiLevelExitCore::previsit( const ast::SwitchStmt * stmt ) {
    442         ast::Label label = LabelGenerator::newLabel( "switchBreak", stmt );
    443         auto it = std::find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
    444 
    445         const ast::CaseStmt * defaultCase = it != stmt->stmts.rend()
    446                 ? (it)->strict_as<ast::CaseStmt>() : nullptr;
    447         ast::Label defaultLabel = defaultCase
    448                 ? LabelGenerator::newLabel( "fallThroughDefault", defaultCase )
    449                 : ast::Label( stmt->location, "" );
     440void MultiLevelExitCore::previsit( const SwitchStmt * stmt ) {
     441        Label label = newLabel( "switchBreak", stmt );
     442        auto it = find_if( stmt->stmts.rbegin(), stmt->stmts.rend(), isDefaultCase );
     443
     444        const CaseStmt * defaultCase = it != stmt->stmts.rend() ? (it)->strict_as<CaseStmt>() : nullptr;
     445        Label defaultLabel = defaultCase ? newLabel( "fallThroughDefault", defaultCase ) : Label( stmt->location, "" );
    450446        enclosing_control_structures.emplace_back( stmt, label, defaultLabel );
    451447        GuardAction( [this]() { enclosing_control_structures.pop_back(); } );
    452448
    453         // Collect valid labels for fallthrough. It starts with all labels at
    454         // this level, then removed as we see them in traversal.
    455         for ( const ast::Stmt * stmt : stmt->stmts ) {
    456                 auto * caseStmt = strict_dynamic_cast< const ast::CaseStmt * >( stmt );
     449        // Collect valid labels for fallthrough. It starts with all labels at this level, then remove as each is seen during
     450        // traversal.
     451        for ( const Stmt * stmt : stmt->stmts ) {
     452                auto * caseStmt = strict_dynamic_cast< const CaseStmt * >( stmt );
    457453                if ( caseStmt->stmts.empty() ) continue;
    458                 auto block = caseStmt->stmts.front().strict_as<ast::CompoundStmt>();
    459                 for ( const ast::Stmt * stmt : block->kids ) {
    460                         for ( const ast::Label & l : stmt->labels ) {
     454                auto block = caseStmt->stmts.front().strict_as<CompoundStmt>();
     455                for ( const Stmt * stmt : block->kids ) {
     456                        for ( const Label & l : stmt->labels ) {
    461457                                fallthrough_labels.insert( l );
    462458                        }
    … …  
    465461}
    466462
    467 const ast::SwitchStmt * MultiLevelExitCore::postvisit( const ast::SwitchStmt * stmt ) {
    468         assert( !enclosing_control_structures.empty() );
     463const SwitchStmt * MultiLevelExitCore::postvisit( const SwitchStmt * stmt ) {
     464        assert( ! enclosing_control_structures.empty() );
    469465        Entry & entry = enclosing_control_structures.back();
    470466        assert( entry.stmt == stmt );
    471467
    472         // Only run if we need to generate the break label.
     468        // Only run to generate the break label.
    473469        if ( entry.isBreakUsed() ) {
    474                 // To keep the switch statements uniform (all direct children of a
    475                 // SwitchStmt should be CastStmts), append the exit label and break
    476                 // to the last case, create a default case is there are no cases.
    477                 ast::SwitchStmt * mutStmt = ast::mutate( stmt );
     470                // To keep the switch statements uniform (all direct children of a SwitchStmt should be CastStmts), append the
     471                // exit label and break to the last case, create a default case if no cases.
     472                SwitchStmt * mutStmt = mutate( stmt );
    478473                if ( mutStmt->stmts.empty() ) {
    479                         mutStmt->stmts.push_back( new ast::CaseStmt(
    480                                 mutStmt->location, nullptr, {} ));
    481                 }
    482 
    483                 auto caseStmt = mutStmt->stmts.back().strict_as<ast::CaseStmt>();
    484                 auto mutCase = ast::mutate( caseStmt );
     474                        mutStmt->stmts.push_back( new CaseStmt( mutStmt->location, nullptr, {} ) );
     475                }
     476
     477                auto caseStmt = mutStmt->stmts.back().strict_as<CaseStmt>();
     478                auto mutCase = mutate( caseStmt );
    485479                mutStmt->stmts.back() = mutCase;
    486480
    487                 ast::Label label( mutCase->location, "breakLabel" );
    488                 auto branch = new ast::BranchStmt( mutCase->location, ast::BranchStmt::Break, label );
     481                Label label( mutCase->location, "breakLabel" );
     482                auto branch = new BranchStmt( mutCase->location, BranchStmt::Break, label );
    489483                branch->labels.push_back( entry.useBreakExit() );
    490484                mutCase->stmts.push_back( branch );
    … …  
    495489}
    496490
    497 void MultiLevelExitCore::previsit( const ast::ReturnStmt * stmt ) {
     491void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
    498492        if ( inFinally ) {
    499493                SemanticError( stmt->location, "'return' may not appear in a finally clause" );
    … …  
    501495}
    502496
    503 void MultiLevelExitCore::previsit( const ast::TryStmt * stmt ) {
    504         bool isLabeled = !stmt->labels.empty();
     497void MultiLevelExitCore::previsit( const TryStmt * stmt ) {
     498        bool isLabeled = ! stmt->labels.empty();
    505499        if ( isLabeled ) {
    506                 ast::Label breakLabel = LabelGenerator::newLabel( "blockBreak", stmt );
     500                Label breakLabel = newLabel( "blockBreak", stmt );
    507501                enclosing_control_structures.emplace_back( stmt, breakLabel );
    508502                GuardAction([this](){ enclosing_control_structures.pop_back(); } );
    … …  
    510504}
    511505
    512 void MultiLevelExitCore::postvisit( const ast::TryStmt * stmt ) {
    513         bool isLabeled = !stmt->labels.empty();
     506void MultiLevelExitCore::postvisit( const TryStmt * stmt ) {
     507        bool isLabeled = ! stmt->labels.empty();
    514508        if ( isLabeled ) {
    515509                auto this_label = enclosing_control_structures.back().useBreakExit();
    516                 if ( !this_label.empty() ) {
     510                if ( ! this_label.empty() ) {
    517511                        break_label = this_label;
    518512                }
    … …  
    520514}
    521515
    522 void MultiLevelExitCore::previsit( const ast::FinallyStmt * ) {
    523         GuardAction([this, old = std::move(enclosing_control_structures)](){
    524                 enclosing_control_structures = std::move(old);
    525         });
    526         enclosing_control_structures = std::vector<Entry>();
     516void MultiLevelExitCore::previsit( const FinallyStmt * ) {
     517        GuardAction([this, old = move( enclosing_control_structures)](){ enclosing_control_structures = move(old); });
     518        enclosing_control_structures = vector<Entry>();
    527519        GuardValue( inFinally ) = true;
    528520}
    529521
    530 const ast::Stmt * MultiLevelExitCore::mutateLoop(
    531                 const ast::Stmt * body, Entry & entry ) {
     522const Stmt * MultiLevelExitCore::mutateLoop(
     523        const Stmt * body, Entry & entry ) {
    532524        if ( entry.isBreakUsed() ) {
    533525                break_label = entry.useBreakExit();
    534526        }
    535527
     528        // if continue is used insert a continue label into the back of the body of the loop
    536529        if ( entry.isContUsed() ) {
    537                 ast::CompoundStmt * new_body = new ast::CompoundStmt( body->location );
     530                CompoundStmt * new_body = new CompoundStmt( body->location );
     531                // {}
    538532                new_body->kids.push_back( body );
     533                // {
     534                //  body
     535                // }
    539536                new_body->kids.push_back(
    540537                        labelledNullStmt( body->location, entry.useContExit() ) );
     538                // {
     539                //  body
     540                //  ContinueLabel: {}
     541                // }
    541542                return new_body;
    542543        }
    … …  
    549550        // Remember is loop before going onto mutate the body.
    550551        // The labels will be folded in if they are used.
    551         ast::Label breakLabel = LabelGenerator::newLabel( "loopBreak", loopStmt );
    552         ast::Label contLabel = LabelGenerator::newLabel( "loopContinue", loopStmt );
     552        Label breakLabel = newLabel( "loopBreak", loopStmt );
     553        Label contLabel = newLabel( "loopContinue", loopStmt );
    553554        enclosing_control_structures.emplace_back( loopStmt, breakLabel, contLabel );
     555        // labels are added temporarily to see if they are used and then added permanently in postvisit if ther are used
     556        // children will tag labels as being used during their traversal which occurs before postvisit
     557
     558        // GuardAction calls the lambda after the node is done being visited
    554559        GuardAction( [this](){ enclosing_control_structures.pop_back(); } );
    555560}
    … …  
    557562template<typename LoopNode>
    558563const LoopNode * MultiLevelExitCore::posthandleLoopStmt( const LoopNode * loopStmt ) {
    559         assert( !enclosing_control_structures.empty() );
     564        assert( ! enclosing_control_structures.empty() );
    560565        Entry & entry = enclosing_control_structures.back();
    561566        assert( entry.stmt == loopStmt );
    562567
    563         // Now we check if the labels are used and add them if so.
    564         return ast::mutate_field(
    565                 loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
    566 }
    567 
    568 std::list<ast::ptr<ast::Stmt>> MultiLevelExitCore::fixBlock(
    569                 const std::list<ast::ptr<ast::Stmt>> & kids, bool is_case_clause ) {
    570         // Unfortunately we can't use the automatic error collection.
     568        // Now check if the labels are used and add them if so.
     569        return mutate_field( loopStmt, &LoopNode::body, mutateLoop( loopStmt->body, entry ) );
     570        // this call to mutate_field compares loopStmt->body and the result of mutateLoop
     571        //              if they are the same the node isn't mutated, if they differ then the new mutated node is returned
     572        //              the stmts will only differ if a label is used
     573}
     574
     575list<ptr<Stmt>> MultiLevelExitCore::fixBlock(
     576        const list<ptr<Stmt>> & kids, bool is_case_clause ) {
     577        // Unfortunately cannot use automatic error collection.
    571578        SemanticErrorException errors;
    572579
    573         std::list<ast::ptr<ast::Stmt>> ret;
     580        list<ptr<Stmt>> ret;
    574581
    575582        // Manually visit each child.
    576         for ( const ast::ptr<ast::Stmt> & kid : kids ) {
     583        for ( const ptr<Stmt> & kid : kids ) {
    577584                if ( is_case_clause ) {
    578585                        // Once a label is seen, it's no longer a valid for fallthrough.
    579                         for ( const ast::Label & l : kid->labels ) {
     586                        for ( const Label & l : kid->labels ) {
    580587                                fallthrough_labels.erase( l );
    581588                        }
    … …  
    588595                }
    589596
    590                 if ( !break_label.empty() ) {
    591                         ret.push_back(
    592                                 labelledNullStmt( ret.back()->location, break_label ) );
    593                         break_label = ast::Label( CodeLocation(), "" );
    594                 }
    595         }
    596 
    597         if ( !errors.isEmpty() ) {
     597                if ( ! break_label.empty() ) {
     598                        ret.push_back( labelledNullStmt( ret.back()->location, break_label ) );
     599                        break_label = Label( CodeLocation(), "" );
     600                }
     601        }
     602
     603        if ( ! errors.isEmpty() ) {
    598604                throw errors;
    599605        }
    … …  
    601607}
    602608
    603 } // namespace
    604 
    605 const ast::CompoundStmt * multiLevelExitUpdate(
    606         const ast::CompoundStmt * stmt,
    607                 const LabelToStmt & labelTable ) {
     609const CompoundStmt * multiLevelExitUpdate(
     610        const CompoundStmt * stmt,
     611        const LabelToStmt & labelTable ) {
    608612        // Must start in the body, so FunctionDecls can be a stopping point.
    609         ast::Pass<MultiLevelExitCore> visitor( labelTable );
    610         const ast::CompoundStmt * ret = stmt->accept( visitor );
     613        Pass<MultiLevelExitCore> visitor( labelTable );
     614        const CompoundStmt * ret = stmt->accept( visitor );
    611615        return ret;
    612616}
    613 
    614617} // namespace ControlStruct
    615618

  • src/ControlStruct/MultiLevelExit.hpp

    r97c215f rf5a51db  
    99// Author           : Andrew Beach
    1010// Created On       : Mon Nov  1 13:49:00 2021
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Nov  8 10:53:00 2021
    13 // Update Count     : 3
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Mon Jan 31 22:34:06 2022
     13// Update Count     : 6
    1414//
    1515
    … …  
    1919
    2020namespace ast {
    21         class CompoundStmt;
    22         class Label;
    23         class Stmt;
     21class CompoundStmt;
     22class Label;
     23class Stmt;
    2424}
    2525
    2626namespace ControlStruct {
    27 
    2827using LabelToStmt = std::map<ast::Label, const ast::Stmt *>;
    2928
    30 /// Mutate a function body to handle multi-level exits.
    31 const ast::CompoundStmt * multiLevelExitUpdate(
    32         const ast::CompoundStmt *, const LabelToStmt & );
    33 
     29// Mutate a function body to handle multi-level exits.
     30const ast::CompoundStmt * multiLevelExitUpdate( const ast::CompoundStmt *, const LabelToStmt & );
    3431}
    3532

  • src/ControlStruct/module.mk

    r97c215f rf5a51db  
    1010## Author           : Richard C. Bilson
    1111## Created On       : Mon Jun  1 17:49:17 2015
    12 ## Last Modified By : Henry Xue
    13 ## Last Modified On : Tue Jul 20 04:10:50 2021
    14 ## Update Count     : 5
     12## Last Modified By : Peter A. Buhr
     13## Last Modified On : Sat Jan 29 12:04:19 2022
     14## Update Count     : 7
    1515###############################################################################
    1616
    … …  
    2222        ControlStruct/ForExprMutator.cc \
    2323        ControlStruct/ForExprMutator.h \
     24        ControlStruct/HoistControlDecls.cpp \
     25        ControlStruct/HoistControlDecls.hpp \
    2426        ControlStruct/LabelFixer.cc \
    2527        ControlStruct/LabelFixer.h \
    2628        ControlStruct/LabelGenerator.cc \
    2729        ControlStruct/LabelGenerator.h \
     30        ControlStruct/LabelGeneratorNew.cpp \
     31        ControlStruct/LabelGeneratorNew.hpp \
    2832        ControlStruct/MLEMutator.cc \
    2933        ControlStruct/MLEMutator.h \

  • src/InitTweak/InitTweak.cc

    r97c215f rf5a51db  
    1010// Created On       : Fri May 13 11:26:36 2016
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Nov 19 19:22:00 2021
    13 // Update Count     : 19
     12// Last Modified On : Mon Dec  6 13:21:00 2021
     13// Update Count     : 20
    1414//
    1515
    … …  
    11911191        }
    11921192
    1193         bool isCopyFunction( const ast::FunctionDecl * decl ) {
    1194                 const ast::FunctionType * ftype = decl->type;
    1195                 if ( ftype->params.size() != 2 ) return false;
    1196 
    1197                 const ast::Type * t1 = getPointerBase( ftype->params.front() );
    1198                 if ( ! t1 ) return false;
    1199                 const ast::Type * t2 = ftype->params.back();
    1200 
    1201                 return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
    1202         }
     1193bool isAssignment( const ast::FunctionDecl * decl ) {
     1194        return isAssignment( decl->name ) && isCopyFunction( decl );
     1195}
     1196
     1197bool isDestructor( const ast::FunctionDecl * decl ) {
     1198        return isDestructor( decl->name );
     1199}
     1200
     1201bool isDefaultConstructor( const ast::FunctionDecl * decl ) {
     1202        return isConstructor( decl->name ) && 1 == decl->params.size();
     1203}
     1204
     1205bool isCopyConstructor( const ast::FunctionDecl * decl ) {
     1206        return isConstructor( decl->name ) && 2 == decl->params.size();
     1207}
     1208
     1209bool isCopyFunction( const ast::FunctionDecl * decl ) {
     1210        const ast::FunctionType * ftype = decl->type;
     1211        if ( ftype->params.size() != 2 ) return false;
     1212
     1213        const ast::Type * t1 = getPointerBase( ftype->params.front() );
     1214        if ( ! t1 ) return false;
     1215        const ast::Type * t2 = ftype->params.back();
     1216
     1217        return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
     1218}
    12031219
    12041220        const FunctionDecl * isAssignment( const Declaration * decl ) {

  • src/InitTweak/InitTweak.h

    r97c215f rf5a51db  
    1010// Created On       : Fri May 13 11:26:36 2016
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Nov 19 14:18:00 2021
    13 // Update Count     : 7
     12// Last Modified On : Mon Dec  6 13:20:00 2021
     13// Update Count     : 8
    1414//
    1515
    … …  
    3131        const FunctionDecl * isCopyConstructor( const Declaration * decl );
    3232        const FunctionDecl * isCopyFunction( const Declaration * decl, const std::string & fname );
     33        bool isAssignment( const ast::FunctionDecl * decl );
     34        bool isDestructor( const ast::FunctionDecl * decl );
     35        bool isDefaultConstructor( const ast::FunctionDecl * decl );
     36        bool isCopyConstructor( const ast::FunctionDecl * decl );
    3337        bool isCopyFunction( const ast::FunctionDecl * decl );
    3438

  • src/Parser/ParseNode.h

    r97c215f rf5a51db  
    1010// Created On       : Sat May 16 13:28:16 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Wed Jul 14 17:28:53 2021
    13 // Update Count     : 900
     12// Last Modified On : Wed Feb  2 09:15:49 2022
     13// Update Count     : 905
    1414//
    1515
    … …  
    390390Statement * build_expr( ExpressionNode * ctl );
    391391
    392 struct IfCtrl {
    393         IfCtrl( DeclarationNode * decl, ExpressionNode * condition ) :
     392struct CondCtl {
     393        CondCtl( DeclarationNode * decl, ExpressionNode * condition ) :
    394394                init( decl ? new StatementNode( decl ) : nullptr ), condition( condition ) {}
    395395
    … …  
    409409};
    410410
    411 Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init );
    412 Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt );
     411Expression * build_if_control( CondCtl * ctl, std::list< Statement * > & init );
     412Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ );
    413413Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt );
    414414Statement * build_case( ExpressionNode * ctl );
    415415Statement * build_default();
    416 Statement * build_while( IfCtrl * ctl, StatementNode * stmt );
    417 Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt );
    418 Statement * build_for( ForCtrl * forctl, StatementNode * stmt );
     416Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
     417Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ = nullptr );
     418Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ = nullptr );
    419419Statement * build_branch( BranchStmt::Type kind );
    420420Statement * build_branch( std::string * identifier, BranchStmt::Type kind );
    … …  
    424424Statement * build_resume( ExpressionNode * ctl );
    425425Statement * build_resume_at( ExpressionNode * ctl , ExpressionNode * target );
    426 Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt );
    427 Statement * build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body );
     426Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ );
     427Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body );
    428428Statement * build_finally( StatementNode * stmt );
    429429Statement * build_compound( StatementNode * first );

  • src/Parser/StatementNode.cc

    r97c215f rf5a51db  
    55// file "LICENCE" distributed with Cforall.
    66//
    7 // StatementNode.cc --
     7// StatementNode.cc -- Transform from parse data-structures to AST data-structures, usually deleting the parse
     8//     data-structure after the transformation.
    89//
    910// Author           : Rodolfo G. Esteves
    1011// Created On       : Sat May 16 14:59:41 2015
    1112// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Oct 24 04:20:55 2020
    13 // Update Count     : 383
     13// Last Modified On : Wed Feb  2 20:29:30 2022
     14// Update Count     : 425
    1415//
    1516
    … …  
    6364        // convert from StatementNode list to Statement list
    6465        StatementNode * node = dynamic_cast< StatementNode * >(prev);
    65         std::list< Statement * > stmts;
     66        list< Statement * > stmts;
    6667        buildMoveList( stmt, stmts );
    6768        // splice any new Statements to end of current Statements
    … …  
    7879} // build_expr
    7980
    80 Expression * build_if_control( IfCtrl * ctl, std::list< Statement * > & init ) {
     81Expression * build_if_control( CondCtl * ctl, list< Statement * > & init ) {
    8182        if ( ctl->init != 0 ) {
    8283                buildMoveList( ctl->init, init );
    … …  
    100101} // build_if_control
    101102
    102 Statement * build_if( IfCtrl * ctl, StatementNode * then_stmt, StatementNode * else_stmt ) {
    103         Statement * thenb, * elseb = nullptr;
    104         std::list< Statement * > branches;
    105         buildMoveList< Statement, StatementNode >( then_stmt, branches );
    106         assert( branches.size() == 1 );
    107         thenb = branches.front();
    108 
    109         if ( else_stmt ) {
    110                 std::list< Statement * > branches;
    111                 buildMoveList< Statement, StatementNode >( else_stmt, branches );
    112                 assert( branches.size() == 1 );
    113                 elseb = branches.front();
    114         } // if
    115 
    116         std::list< Statement * > init;
    117         Expression * cond = build_if_control( ctl, init );
    118         return new IfStmt( cond, thenb, elseb, init );
     103Statement * build_if( CondCtl * ctl, StatementNode * then, StatementNode * else_ ) {
     104        list< Statement * > astinit;                                            // maybe empty
     105        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
     106
     107        Statement * astthen, * astelse = nullptr;
     108        list< Statement * > aststmt;
     109        buildMoveList< Statement, StatementNode >( then, aststmt );
     110        assert( aststmt.size() == 1 );
     111        astthen = aststmt.front();
     112
     113        if ( else_ ) {
     114                list< Statement * > aststmt;
     115                buildMoveList< Statement, StatementNode >( else_, aststmt );
     116                assert( aststmt.size() == 1 );
     117                astelse = aststmt.front();
     118        } // if
     119
     120        return new IfStmt( astcond, astthen, astelse, astinit );
    119121} // build_if
    120122
    121123Statement * build_switch( bool isSwitch, ExpressionNode * ctl, StatementNode * stmt ) {
    122         std::list< Statement * > branches;
    123         buildMoveList< Statement, StatementNode >( stmt, branches );
    124         if ( ! isSwitch ) {                                                                             // choose statement
    125                 for ( Statement * stmt : branches ) {
     124        list< Statement * > aststmt;
     125        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     126        if ( ! isSwitch ) {                                                                     // choose statement
     127                for ( Statement * stmt : aststmt ) {
    126128                        CaseStmt * caseStmt = strict_dynamic_cast< CaseStmt * >( stmt );
    127129                        if ( ! caseStmt->stmts.empty() ) {                      // code after "case" => end of case list
    … …  
    131133                } // for
    132134        } // if
    133         // branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
    134         return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );
     135        // aststmt.size() == 0 for switch (...) {}, i.e., no declaration or statements
     136        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), aststmt );
    135137} // build_switch
    136138
    137139Statement * build_case( ExpressionNode * ctl ) {
    138         std::list< Statement * > branches;
    139         return new CaseStmt( maybeMoveBuild< Expression >(ctl), branches );
     140        return new CaseStmt( maybeMoveBuild< Expression >(ctl), {} ); // stmt starts empty and then added to
    140141} // build_case
    141142
    142143Statement * build_default() {
    143         std::list< Statement * > branches;
    144         return new CaseStmt( nullptr, branches, true );
     144        return new CaseStmt( nullptr, {}, true );                       // stmt starts empty and then added to
    145145} // build_default
    146146
    147 Statement * build_while( IfCtrl * ctl, StatementNode * stmt ) {
    148         std::list< Statement * > branches;
    149         buildMoveList< Statement, StatementNode >( stmt, branches );
    150         assert( branches.size() == 1 );
    151 
    152         std::list< Statement * > init;
    153         Expression * cond = build_if_control( ctl, init );
    154         return new WhileStmt( cond, branches.front(), init, false );
     147Statement * build_while( CondCtl * ctl, StatementNode * stmt, StatementNode * else_ ) {
     148        list< Statement * > astinit;                                            // maybe empty
     149        Expression * astcond = build_if_control( ctl, astinit ); // ctl deleted, cond/init set
     150
     151        list< Statement * > aststmt;                                            // loop body, compound created if empty
     152        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     153        assert( aststmt.size() == 1 );
     154
     155        list< Statement * > astelse;                                            // else clause, maybe empty
     156        buildMoveList< Statement, StatementNode >( else_, astelse );
     157
     158        return new WhileDoStmt( astcond, aststmt.front(), astelse.front(), astinit, false );
    155159} // build_while
    156160
    157 Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt ) {
    158         std::list< Statement * > branches;
    159         buildMoveList< Statement, StatementNode >( stmt, branches );
    160         assert( branches.size() == 1 );
    161 
    162         std::list< Statement * > init;
    163         return new WhileStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), init, true );
     161Statement * build_do_while( ExpressionNode * ctl, StatementNode * stmt, StatementNode * else_ ) {
     162        list< Statement * > aststmt;                                            // loop body, compound created if empty
     163        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     164        assert( aststmt.size() == 1 );                                          // compound created if empty
     165
     166        list< Statement * > astelse;                                            // else clause, maybe empty
     167        buildMoveList< Statement, StatementNode >( else_, astelse );
     168
     169        // do-while cannot have declarations in the contitional, so init is always empty
     170        return new WhileDoStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), aststmt.front(), astelse.front(), {}, true );
    164171} // build_do_while
    165172
    166 Statement * build_for( ForCtrl * forctl, StatementNode * stmt ) {
    167         std::list< Statement * > branches;
    168         buildMoveList< Statement, StatementNode >( stmt, branches );
    169         assert( branches.size() == 1 );
    170 
    171         std::list< Statement * > init;
    172         if ( forctl->init != 0 ) {
    173                 buildMoveList( forctl->init, init );
    174         } // if
    175 
    176         Expression * cond = 0;
    177         if ( forctl->condition != 0 )
    178                 cond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
    179 
    180         Expression * incr = 0;
    181         if ( forctl->change != 0 )
    182                 incr = maybeMoveBuild< Expression >(forctl->change);
    183 
     173Statement * build_for( ForCtrl * forctl, StatementNode * stmt, StatementNode * else_ ) {
     174        list< Statement * > astinit;                                            // maybe empty
     175        buildMoveList( forctl->init, astinit );
     176
     177        Expression * astcond = nullptr;                                         // maybe empty
     178        astcond = notZeroExpr( maybeMoveBuild< Expression >(forctl->condition) );
     179
     180        Expression * astincr = nullptr;                                         // maybe empty
     181        astincr = maybeMoveBuild< Expression >(forctl->change);
    184182        delete forctl;
    185         return new ForStmt( init, cond, incr, branches.front() );
     183
     184        list< Statement * > aststmt;                                            // loop body, compound created if empty
     185        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     186        assert( aststmt.size() == 1 );
     187
     188        list< Statement * > astelse;                                            // else clause, maybe empty
     189        buildMoveList< Statement, StatementNode >( else_, astelse );
     190
     191        return new ForStmt( astinit, astcond, astincr, aststmt.front(), astelse.front() );
    186192} // build_for
    187193
    … …  
    191197} // build_branch
    192198
    193 Statement * build_branch( std::string * identifier, BranchStmt::Type kind ) {
     199Statement * build_branch( string * identifier, BranchStmt::Type kind ) {
    194200        Statement * ret = new BranchStmt( * identifier, kind );
    195201        delete identifier;                                                                      // allocated by lexer
    … …  
    202208
    203209Statement * build_return( ExpressionNode * ctl ) {
    204         std::list< Expression * > exps;
     210        list< Expression * > exps;
    205211        buildMoveList( ctl, exps );
    206212        return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
    … …  
    208214
    209215Statement * build_throw( ExpressionNode * ctl ) {
    210         std::list< Expression * > exps;
     216        list< Expression * > exps;
    211217        buildMoveList( ctl, exps );
    212         assertf( exps.size() < 2, "This means we are leaking memory");
     218        assertf( exps.size() < 2, "CFA internal error: leaking memory" );
    213219        return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
    214220} // build_throw
    215221
    216222Statement * build_resume( ExpressionNode * ctl ) {
    217         std::list< Expression * > exps;
     223        list< Expression * > exps;
    218224        buildMoveList( ctl, exps );
    219         assertf( exps.size() < 2, "This means we are leaking memory");
     225        assertf( exps.size() < 2, "CFA internal error: leaking memory" );
    220226        return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
    221227} // build_resume
    … …  
    227233} // build_resume_at
    228234
    229 Statement * build_try( StatementNode * try_stmt, StatementNode * catch_stmt, StatementNode * finally_stmt ) {
    230         std::list< CatchStmt * > branches;
    231         buildMoveList< CatchStmt, StatementNode >( catch_stmt, branches );
    232         CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
    233         FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
    234         return new TryStmt( tryBlock, branches, finallyBlock );
     235Statement * build_try( StatementNode * try_, StatementNode * catch_, StatementNode * finally_ ) {
     236        list< CatchStmt * > aststmt;
     237        buildMoveList< CatchStmt, StatementNode >( catch_, aststmt );
     238        CompoundStmt * tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_));
     239        FinallyStmt * finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_) );
     240        return new TryStmt( tryBlock, aststmt, finallyBlock );
    235241} // build_try
    236242
    237243Statement * build_catch( CatchStmt::Kind kind, DeclarationNode * decl, ExpressionNode * cond, StatementNode * body ) {
    238         std::list< Statement * > branches;
    239         buildMoveList< Statement, StatementNode >( body, branches );
    240         assert( branches.size() == 1 );
    241         return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
     244        list< Statement * > aststmt;
     245        buildMoveList< Statement, StatementNode >( body, aststmt );
     246        assert( aststmt.size() == 1 );
     247        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), aststmt.front() );
    242248} // build_catch
    243249
    244250Statement * build_finally( StatementNode * stmt ) {
    245         std::list< Statement * > branches;
    246         buildMoveList< Statement, StatementNode >( stmt, branches );
    247         assert( branches.size() == 1 );
    248         return new FinallyStmt( dynamic_cast< CompoundStmt * >( branches.front() ) );
     251        list< Statement * > aststmt;
     252        buildMoveList< Statement, StatementNode >( stmt, aststmt );
     253        assert( aststmt.size() == 1 );
     254        return new FinallyStmt( dynamic_cast< CompoundStmt * >( aststmt.front() ) );
    249255} // build_finally
    250256
    … …  
    254260        node->type = type;
    255261
    256         std::list< Statement * > stmts;
     262        list< Statement * > stmts;
    257263        buildMoveList< Statement, StatementNode >( then, stmts );
    258264        if(!stmts.empty()) {
    … …  
    319325} // build_waitfor_timeout
    320326
    321 WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_stmt, ExpressionNode * else_when ) {
     327WaitForStmt * build_waitfor_timeout( ExpressionNode * timeout, StatementNode * stmt, ExpressionNode * when,  StatementNode * else_, ExpressionNode * else_when ) {
    322328        auto node = new WaitForStmt();
    323329
    … …  
    326332        node->timeout.condition = notZeroExpr( maybeMoveBuild<Expression>( when ) );
    327333
    328         node->orelse.statement  = maybeMoveBuild<Statement >( else_stmt );
     334        node->orelse.statement  = maybeMoveBuild<Statement >( else_ );
    329335        node->orelse.condition  = notZeroExpr( maybeMoveBuild<Expression>( else_when ) );
    330336
    … …  
    333339
    334340Statement * build_with( ExpressionNode * exprs, StatementNode * stmt ) {
    335         std::list< Expression * > e;
     341        list< Expression * > e;
    336342        buildMoveList( exprs, e );
    337343        Statement * s = maybeMoveBuild<Statement>( stmt );
    … …  
    361367
    362368Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
    363         std::list< Expression * > out, in;
    364         std::list< ConstantExpr * > clob;
     369        list< Expression * > out, in;
     370        list< ConstantExpr * > clob;
    365371
    366372        buildMoveList( output, out );
    … …  
    375381
    376382Statement * build_mutex( ExpressionNode * exprs, StatementNode * stmt ) {
    377         std::list< Expression * > expList;
     383        list< Expression * > expList;
    378384        buildMoveList( exprs, expList );
    379385        Statement * body = maybeMoveBuild<Statement>( stmt );

  • src/Parser/parser.yy

    r97c215f rf5a51db  
    1010// Created On       : Sat Sep  1 20:22:55 2001
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Oct 15 09:20:17 2021
    13 // Update Count     : 5163
     12// Last Modified On : Tue Feb  1 11:06:13 2022
     13// Update Count     : 5167
    1414//
    1515
    … …  
    238238        WaitForStmt * wfs;
    239239        Expression * constant;
    240         IfCtrl * ifctl;
     240        CondCtl * ifctl;
    241241        ForCtrl * fctl;
    242242        enum OperKinds compop;
    … …  
    327327%type<en> comma_expression                              comma_expression_opt
    328328%type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
    329 %type<ifctl> if_control_expression
     329%type<ifctl> conditional_declaration
    330330%type<fctl> for_control_expression              for_control_expression_list
    331331%type<compop> inclexcl
    … …  
    11231123
    11241124if_statement:
    1125         IF '(' if_control_expression ')' statement                      %prec THEN
     1125        IF '(' conditional_declaration ')' statement            %prec THEN
    11261126                // explicitly deal with the shift/reduce conflict on if/else
    11271127                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
    1128         | IF '(' if_control_expression ')' statement ELSE statement
     1128        | IF '(' conditional_declaration ')' statement ELSE statement
    11291129                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
    11301130        ;
    11311131
    1132 if_control_expression:
     1132conditional_declaration:
    11331133        comma_expression
    1134                 { $$ = new IfCtrl( nullptr, $1 ); }
     1134                { $$ = new CondCtl( nullptr, $1 ); }
    11351135        | c_declaration                                                                         // no semi-colon
    1136                 { $$ = new IfCtrl( $1, nullptr ); }
     1136                { $$ = new CondCtl( $1, nullptr ); }
    11371137        | cfa_declaration                                                                       // no semi-colon
    1138                 { $$ = new IfCtrl( $1, nullptr ); }
     1138                { $$ = new CondCtl( $1, nullptr ); }
    11391139        | declaration comma_expression                                          // semi-colon separated
    1140                 { $$ = new IfCtrl( $1, $2 ); }
     1140                { $$ = new CondCtl( $1, $2 ); }
    11411141        ;
    11421142
    … …  
    11931193iteration_statement:
    11941194        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
    1195                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
    1196         | WHILE '(' if_control_expression ')' statement         %prec THEN
     1195                { $$ = new StatementNode( build_while( new CondCtl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
     1196        | WHILE '(' conditional_declaration ')' statement       %prec THEN
    11971197                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
    1198         | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
    1199                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1198        | WHILE '(' conditional_declaration ')' statement ELSE statement // CFA
     1199                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1200                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ), $7 ) ); }
    12001201        | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
    12011202                { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
    … …  
    12031204                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
    12041205        | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
    1205                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1206                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1207                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ), $8 ) ); }
    12061208        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
    12071209                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
    … …  
    12091211                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
    12101212        | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
    1211                 { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1213                // { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
     1214                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ), $7 ) ); }
    12121215        ;
    12131216

  • src/ResolvExpr/Resolver.cc

    r97c215f rf5a51db  
    99// Author           : Aaron B. Moss
    1010// Created On       : Sun May 17 12:17:01 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Fri Mar 27 11:58:00 2020
    13 // Update Count     : 242
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Feb  1 16:27:14 2022
     13// Update Count     : 245
    1414//
    1515
    … …  
    8080                void previsit( AsmStmt * asmStmt );
    8181                void previsit( IfStmt * ifStmt );
    82                 void previsit( WhileStmt * whileStmt );
     82                void previsit( WhileDoStmt * whileDoStmt );
    8383                void previsit( ForStmt * forStmt );
    8484                void previsit( SwitchStmt * switchStmt );
    … …  
    502502        }
    503503
    504         void Resolver_old::previsit( WhileStmt * whileStmt ) {
    505                 findIntegralExpression( whileStmt->condition, indexer );
     504        void Resolver_old::previsit( WhileDoStmt * whileDoStmt ) {
     505                findIntegralExpression( whileDoStmt->condition, indexer );
    506506        }
    507507
    … …  
    572572
    573573        void Resolver_old::previsit( CatchStmt * catchStmt ) {
    574                 // Until we are very sure this invarent (ifs that move between passes have thenPart)
     574                // Until we are very sure this invarent (ifs that move between passes have then)
    575575                // holds, check it. This allows a check for when to decode the mangling.
    576576                if ( IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body ) ) {
    577                         assert( ifStmt->thenPart );
     577                        assert( ifStmt->then );
    578578                }
    579579                // Encode the catchStmt so the condition can see the declaration.
    … …  
    588588                // Decode the catchStmt so everything is stored properly.
    589589                IfStmt * ifStmt = dynamic_cast<IfStmt *>( catchStmt->body );
    590                 if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
     590                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
    591591                        assert( ifStmt->condition );
    592                         assert( ifStmt->elsePart );
     592                        assert( ifStmt->else_ );
    593593                        catchStmt->cond = ifStmt->condition;
    594                         catchStmt->body = ifStmt->elsePart;
     594                        catchStmt->body = ifStmt->else_;
    595595                        ifStmt->condition = nullptr;
    596                         ifStmt->elsePart = nullptr;
     596                        ifStmt->else_ = nullptr;
    597597                        delete ifStmt;
    598598                }
    … …  
    12721272                const ast::AsmStmt *         previsit( const ast::AsmStmt * );
    12731273                const ast::IfStmt *          previsit( const ast::IfStmt * );
    1274                 const ast::WhileStmt *       previsit( const ast::WhileStmt * );
     1274                const ast::WhileDoStmt *       previsit( const ast::WhileDoStmt * );
    12751275                const ast::ForStmt *         previsit( const ast::ForStmt * );
    12761276                const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
    … …  
    15811581        }
    15821582
    1583         const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
     1583        const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
    15841584                return ast::mutate_field(
    1585                         whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
     1585                        whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, symtab ) );
    15861586        }
    15871587
    … …  
    16691669
    16701670        const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
    1671                 // Until we are very sure this invarent (ifs that move between passes have thenPart)
     1671                // Until we are very sure this invarent (ifs that move between passes have then)
    16721672                // holds, check it. This allows a check for when to decode the mangling.
    16731673                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
    1674                         assert( ifStmt->thenPart );
     1674                        assert( ifStmt->then );
    16751675                }
    16761676                // Encode the catchStmt so the condition can see the declaration.
    … …  
    16871687                // Decode the catchStmt so everything is stored properly.
    16881688                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
    1689                 if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
     1689                if ( nullptr != ifStmt && nullptr == ifStmt->then ) {
    16901690                        assert( ifStmt->cond );
    1691                         assert( ifStmt->elsePart );
     1691                        assert( ifStmt->else_ );
    16921692                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
    16931693                        stmt->cond = ifStmt->cond;
    1694                         stmt->body = ifStmt->elsePart;
     1694                        stmt->body = ifStmt->else_;
    16951695                        // ifStmt should be implicately deleted here.
    16961696                        return stmt;

  • src/SymTab/Validate.cc

    r97c215f rf5a51db  
    453453        }
    454454
     455        void decayForallPointers( std::list< Declaration * > & translationUnit ) {
     456                PassVisitor<ForallPointerDecay_old> fpd;
     457                acceptAll( translationUnit, fpd );
     458        }
     459
    455460        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
    456461                validate_A( translationUnit );
    … …  
    470475                type->accept( fpd );
    471476        }
    472 
    473477
    474478        void HoistTypeDecls::handleType( Type * type ) {

  • src/SymTab/Validate.h

    r97c215f rf5a51db  
    4242        void validate_E( std::list< Declaration * > &translationUnit );
    4343        void validate_F( std::list< Declaration * > &translationUnit );
     44        void decayForallPointers( std::list< Declaration * > & translationUnit );
    4445
    4546        const ast::Type * validateType(

  • src/SynTree/Mutator.h

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:36 2021
    13 // Update Count     : 18
     12// Last Modified On : Tue Feb  1 09:26:49 2022
     13// Update Count     : 20
    1414//
    1515#pragma once
    … …  
    4242        virtual Statement * mutate( DirectiveStmt * dirStmt ) = 0;
    4343        virtual Statement * mutate( IfStmt * ifStmt ) = 0;
    44         virtual Statement * mutate( WhileStmt * whileStmt ) = 0;
     44        virtual Statement * mutate( WhileDoStmt * whileDoStmt ) = 0;
    4545        virtual Statement * mutate( ForStmt * forStmt ) = 0;
    4646        virtual Statement * mutate( SwitchStmt * switchStmt ) = 0;

  • src/SynTree/Statement.cc

    r97c215f rf5a51db  
    99// Author           : Richard C. Bilson
    1010// Created On       : Mon May 18 07:44:20 2015
    11 // Last Modified By : Andrew Beach
    12 // Last Modified On : Mon Jan 20 16:03:00 2020
    13 // Update Count     : 71
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Wed Feb  2 20:19:33 2022
     13// Update Count     : 90
    1414//
    1515
    … …  
    2929#include "SynTree/Label.h"         // for Label, operator<<
    3030
    31 using std::string;
    32 using std::endl;
    33 
    34 Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
    35 
    36 void Statement::print( std::ostream & os, Indenter indent ) const {
     31using namespace std;
     32
     33
     34Statement::Statement( const list<Label> & labels ) : labels( labels ) {}
     35
     36void Statement::print( ostream & os, Indenter indent ) const {
    3737        if ( ! labels.empty() ) {
    3838                os << indent << "... Labels: {";
    … …  
    5454}
    5555
    56 void ExprStmt::print( std::ostream & os, Indenter indent ) const {
    57         os << "Expression Statement:" << endl << indent+1;
    58         expr->print( os, indent+1 );
    59 }
    60 
    61 
    62 AsmStmt::AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
     56void ExprStmt::print( ostream & os, Indenter indent ) const {
     57        os << "Expression Statement:" << endl << indent + 1;
     58        expr->print( os, indent + 1 );
     59}
     60
     61
     62AsmStmt::AsmStmt( bool voltile, Expression * instruction, const list<Expression *> output, const list<Expression *> input, const list<ConstantExpr *> clobber, const list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
    6363
    6464AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
    … …  
    7575}
    7676
    77 void AsmStmt::print( std::ostream & os, Indenter indent ) const {
     77void AsmStmt::print( ostream & os, Indenter indent ) const {
    7878        os << "Assembler Statement:" << endl;
    79         os << indent+1 << "instruction: " << endl << indent;
    80         instruction->print( os, indent+1 );
     79        os << indent + 1 << "instruction: " << endl << indent;
     80        instruction->print( os, indent + 1 );
    8181        if ( ! output.empty() ) {
    82                 os << endl << indent+1 << "output: " << endl;
    83                 printAll( output, os, indent+1 );
     82                os << endl << indent + 1 << "output: " << endl;
     83                printAll( output, os, indent + 1 );
    8484        } // if
    8585        if ( ! input.empty() ) {
    86                 os << indent+1 << "input: " << endl;
    87                 printAll( input, os, indent+1 );
     86                os << indent + 1 << "input: " << endl;
     87                printAll( input, os, indent + 1 );
    8888        } // if
    8989        if ( ! clobber.empty() ) {
    90                 os << indent+1 << "clobber: " << endl;
    91                 printAll( clobber, os, indent+1 );
     90                os << indent + 1 << "clobber: " << endl;
     91                printAll( clobber, os, indent + 1 );
    9292        } // if
    9393}
    9494
    9595
    96 DirectiveStmt::DirectiveStmt( const std::string & directive ) : Statement(), directive( directive ) {}
    97 
    98 void DirectiveStmt::print( std::ostream & os, Indenter ) const {
     96DirectiveStmt::DirectiveStmt( const string & directive ) : Statement(), directive( directive ) {}
     97
     98void DirectiveStmt::print( ostream & os, Indenter ) const {
    9999        os << "GCC Directive:" << directive << endl;
    100100}
    … …  
    120120}
    121121
    122 void BranchStmt::print( std::ostream & os, Indenter indent ) const {
    123         assert(type < 5);
     122void BranchStmt::print( ostream & os, Indenter indent ) const {
     123        assertf(type < BranchStmts, "CFA internal error: invalid branch statement" );
    124124        os << "Branch (" << brType[type] << ")" << endl ;
    125         if ( target != "" ) os << indent+1 << "with target: " << target << endl;
    126         if ( originalTarget != "" ) os << indent+1 << "with original target: " << originalTarget << endl;
    127         if ( computedTarget != nullptr ) os << indent+1 << "with computed target: " << computedTarget << endl;
     125        if ( target != "" ) os << indent + 1 << "with target: " << target << endl;
     126        if ( originalTarget != "" ) os << indent + 1 << "with original target: " << originalTarget << endl;
     127        if ( computedTarget != nullptr ) os << indent + 1 << "with computed target: " << computedTarget << endl;
    128128}
    129129
    … …  
    136136}
    137137
    138 void ReturnStmt::print( std::ostream & os, Indenter indent ) const {
     138void ReturnStmt::print( ostream & os, Indenter indent ) const {
    139139        os << "Return Statement, returning: ";
    140140        if ( expr != nullptr ) {
    141                 os << endl << indent+1;
    142                 expr->print( os, indent+1 );
     141                os << endl << indent + 1;
     142                expr->print( os, indent + 1 );
    143143        }
    144144        os << endl;
    145145}
    146146
    147 IfStmt::IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart, std::list<Statement *> initialization ):
    148         Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
     147IfStmt::IfStmt( Expression * condition, Statement * then, Statement * else_, const list<Statement *> initialization ):
     148        Statement(), condition( condition ), then( then ), else_( else_ ), initialization( initialization ) {}
    149149
    150150IfStmt::IfStmt( const IfStmt & other ) :
    151         Statement( other ), condition( maybeClone( other.condition ) ), thenPart( maybeClone( other.thenPart ) ), elsePart( maybeClone( other.elsePart ) ) {
     151        Statement( other ), condition( maybeClone( other.condition ) ), then( maybeClone( other.then ) ), else_( maybeClone( other.else_ ) ) {
    152152        cloneAll( other.initialization, initialization );
    153153}
    … …  
    156156        deleteAll( initialization );
    157157        delete condition;
    158         delete thenPart;
    159         delete elsePart;
    160 }
    161 
    162 void IfStmt::print( std::ostream & os, Indenter indent ) const {
     158        delete then;
     159        delete else_;
     160}
     161
     162void IfStmt::print( ostream & os, Indenter indent ) const {
    163163        os << "If on condition: " << endl;
    164         os << indent+1;
    165         condition->print( os, indent+1 );
     164        os << indent + 1;
     165        condition->print( os, indent + 1 );
    166166
    167167        if ( !initialization.empty() ) {
    168168                os << indent << "... with initialization: \n";
    169169                for ( const Statement * stmt : initialization ) {
    170                         os << indent+1;
    171                         stmt->print( os, indent+1 );
     170                        os << indent + 1;
     171                        stmt->print( os, indent + 1 );
    172172                }
    173173                os << endl;
    … …  
    176176        os << indent << "... then: " << endl;
    177177
    178         os << indent+1;
    179         thenPart->print( os, indent+1 );
    180 
    181         if ( elsePart != nullptr ) {
     178        os << indent + 1;
     179        then->print( os, indent + 1 );
     180
     181        if ( else_ != nullptr ) {
    182182                os << indent << "... else: " << endl;
    183                 os << indent+1;
    184                 elsePart->print( os, indent+1 );
     183                os << indent + 1;
     184                else_->print( os, indent + 1 );
    185185        } // if
    186186}
    187187
    188 SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> & statements ):
     188SwitchStmt::SwitchStmt( Expression * condition, const list<Statement *> & statements ):
    189189        Statement(), condition( condition ), statements( statements ) {
    190190}
    … …  
    201201}
    202202
    203 void SwitchStmt::print( std::ostream & os, Indenter indent ) const {
     203void SwitchStmt::print( ostream & os, Indenter indent ) const {
    204204        os << "Switch on condition: ";
    205205        condition->print( os );
    … …  
    207207
    208208        for ( const Statement * stmt : statements ) {
    209                 stmt->print( os, indent+1 );
    210         }
    211 }
    212 
    213 CaseStmt::CaseStmt( Expression * condition, const std::list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
    214         Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
     209                stmt->print( os, indent + 1 );
     210        }
     211}
     212
     213CaseStmt::CaseStmt( Expression * condition, const list<Statement *> & statements, bool deflt ) throw ( SemanticErrorException ) :
     214                Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
    215215        if ( isDefault() && condition != nullptr ) SemanticError( condition, "default case with condition: " );
    216216}
    217217
    218218CaseStmt::CaseStmt( const CaseStmt & other ) :
    219         Statement( other ), condition( maybeClone(other.condition ) ), _isDefault( other._isDefault ) {
     219                Statement( other ), condition( maybeClone(other.condition ) ), _isDefault( other._isDefault ) {
    220220        cloneAll( other.stmts, stmts );
    221221}
    … …  
    226226}
    227227
    228 CaseStmt * CaseStmt::makeDefault( const std::list<Label> & labels, std::list<Statement *> stmts ) {
     228CaseStmt * CaseStmt::makeDefault( const list<Label> & labels, list<Statement *> stmts ) {
    229229        CaseStmt * stmt = new CaseStmt( nullptr, stmts, true );
    230230        stmt->labels = labels;
    … …  
    232232}
    233233
    234 void CaseStmt::print( std::ostream & os, Indenter indent ) const {
     234void CaseStmt::print( ostream & os, Indenter indent ) const {
    235235        if ( isDefault() ) os << indent << "Default ";
    236236        else {
    … …  
    241241
    242242        for ( Statement * stmt : stmts ) {
    243                 os << indent+1;
    244                 stmt->print( os, indent+1 );
    245         }
    246 }
    247 
    248 WhileStmt::WhileStmt( Expression * condition, Statement * body, std::list< Statement * > & initialization, bool isDoWhile ):
    249         Statement(), condition( condition), body( body), initialization( initialization ), isDoWhile( isDoWhile) {
    250 }
    251 
    252 WhileStmt::WhileStmt( const WhileStmt & other ):
     243                os << indent + 1;
     244                stmt->print( os, indent + 1 );
     245        }
     246}
     247
     248WhileDoStmt::WhileDoStmt( Expression * condition, Statement * body, const list< Statement * > & initialization, bool isDoWhile ):
     249        Statement(), condition( condition ), body( body ), else_( nullptr ), initialization( initialization ), isDoWhile( isDoWhile) {
     250}
     251
     252WhileDoStmt::WhileDoStmt( Expression * condition, Statement * body, Statement * else_, const list< Statement * > & initialization, bool isDoWhile ):
     253        Statement(), condition( condition), body( body ), else_( else_ ), initialization( initialization ), isDoWhile( isDoWhile) {
     254}
     255
     256WhileDoStmt::WhileDoStmt( const WhileDoStmt & other ):
    253257        Statement( other ), condition( maybeClone( other.condition ) ), body( maybeClone( other.body ) ), isDoWhile( other.isDoWhile ) {
    254258}
    255259
    256 WhileStmt::~WhileStmt() {
     260WhileDoStmt::~WhileDoStmt() {
    257261        delete body;
    258262        delete condition;
    259263}
    260264
    261 void WhileStmt::print( std::ostream & os, Indenter indent ) const {
     265void WhileDoStmt::print( ostream & os, Indenter indent ) const {
    262266        os << "While on condition: " << endl ;
    263         condition->print( os, indent+1 );
     267        condition->print( os, indent + 1 );
    264268
    265269        os << indent << "... with body: " << endl;
    266270
    267         if ( body != nullptr ) body->print( os, indent+1 );
    268 }
    269 
    270 ForStmt::ForStmt( std::list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body ):
    271         Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
     271        if ( body != nullptr ) body->print( os, indent + 1 );
     272}
     273
     274ForStmt::ForStmt( const list<Statement *> initialization, Expression * condition, Expression * increment, Statement * body, Statement * else_ ):
     275        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ), else_( else_ ) {
    272276}
    273277
    274278ForStmt::ForStmt( const ForStmt & other ):
    275         Statement( other ), condition( maybeClone( other.condition ) ), increment( maybeClone( other.increment ) ), body( maybeClone( other.body ) ) {
     279        Statement( other ), condition( maybeClone( other.condition ) ), increment( maybeClone( other.increment ) ), body( maybeClone( other.body ) ), else_( maybeClone( other.else_ ) ) {
    276280                cloneAll( other.initialization, initialization );
    277281
    … …  
    283287        delete increment;
    284288        delete body;
    285 }
    286 
    287 void ForStmt::print( std::ostream & os, Indenter indent ) const {
     289        delete else_;
     290}
     291
     292void ForStmt::print( ostream & os, Indenter indent ) const {
    288293        Statement::print( os, indent ); // print labels
    289294
    … …  
    293298                os << indent << "... initialization: \n";
    294299                for ( Statement * stmt : initialization ) {
    295                         os << indent+1;
    296                         stmt->print( os, indent+1 );
     300                        os << indent + 1;
     301                        stmt->print( os, indent + 1 );
    297302                }
    298303        }
    299304
    300305        if ( condition != nullptr ) {
    301                 os << indent << "... condition: \n" << indent+1;
    302                 condition->print( os, indent+1 );
     306                os << indent << "... condition: \n" << indent + 1;
     307                condition->print( os, indent + 1 );
    303308        }
    304309
    305310        if ( increment != nullptr ) {
    306                 os << "\n" << indent << "... increment: \n" << indent+1;
    307                 increment->print( os, indent+1 );
     311                os << "\n" << indent << "... increment: \n" << indent + 1;
     312                increment->print( os, indent + 1 );
    308313        }
    309314
    310315        if ( body != nullptr ) {
    311                 os << "\n" << indent << "... with body: \n" << indent+1;
    312                 body->print( os, indent+1 );
     316                os << "\n" << indent << "... with body: \n" << indent + 1;
     317                body->print( os, indent + 1 );
     318        }
     319
     320        if ( else_ != nullptr ) {
     321                os << "\n" << indent << "... with body: \n" << indent + 1;
     322                else_->print( os, indent + 1 );
    313323        }
    314324        os << endl;
    … …  
    329339}
    330340
    331 void ThrowStmt::print( std::ostream & os, Indenter indent) const {
     341void ThrowStmt::print( ostream & os, Indenter indent) const {
    332342        if ( target ) os << "Non-Local ";
    333343        os << "Throw Statement, raising: ";
    334         expr->print(os, indent+1);
     344        expr->print(os, indent + 1);
    335345        if ( target ) {
    336346                os << "... at: ";
    337                 target->print(os, indent+1);
    338         }
    339 }
    340 
    341 TryStmt::TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock ) :
     347                target->print(os, indent + 1);
     348        }
     349}
     350
     351TryStmt::TryStmt( CompoundStmt * tryBlock, const list<CatchStmt *> & handlers, FinallyStmt * finallyBlock ) :
    342352        Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
    343353}
    … …  
    353363}
    354364
    355 void TryStmt::print( std::ostream & os, Indenter indent ) const {
     365void TryStmt::print( ostream & os, Indenter indent ) const {
    356366        os << "Try Statement" << endl;
    357         os << indent << "... with block:" << endl << indent+1;
    358         block->print( os, indent+1 );
     367        os << indent << "... with block:" << endl << indent + 1;
     368        block->print( os, indent + 1 );
    359369
    360370        // handlers
    361371        os << indent << "... and handlers:" << endl;
    362372        for ( const CatchStmt * stmt : handlers ) {
    363                 os << indent+1;
    364                 stmt->print( os, indent+1 );
     373                os << indent + 1;
     374                stmt->print( os, indent + 1 );
    365375        }
    366376
    367377        // finally block
    368378        if ( finallyBlock != nullptr ) {
    369                 os << indent << "... and finally:" << endl << indent+1;
    370                 finallyBlock->print( os, indent+1 );
     379                os << indent << "... and finally:" << endl << indent + 1;
     380                finallyBlock->print( os, indent + 1 );
    371381        } // if
    372382}
    … …  
    386396}
    387397
    388 void CatchStmt::print( std::ostream & os, Indenter indent ) const {
     398void CatchStmt::print( ostream & os, Indenter indent ) const {
    389399        os << "Catch " << ((Terminate == kind) ? "Terminate" : "Resume") << " Statement" << endl;
    390400
    391401        os << indent << "... catching: ";
    392         decl->printShort( os, indent+1 );
     402        decl->printShort( os, indent + 1 );
    393403        os << endl;
    394404
    395405        if ( cond ) {
    396                 os << indent << "... with conditional:" << endl << indent+1;
    397                 cond->print( os, indent+1 );
     406                os << indent << "... with conditional:" << endl << indent + 1;
     407                cond->print( os, indent + 1 );
    398408        }
    399409
    400410        os << indent << "... with block:" << endl;
    401         os << indent+1;
    402         body->print( os, indent+1 );
     411        os << indent + 1;
     412        body->print( os, indent + 1 );
    403413}
    404414
    … …  
    414424}
    415425
    416 void FinallyStmt::print( std::ostream & os, Indenter indent ) const {
     426void FinallyStmt::print( ostream & os, Indenter indent ) const {
    417427        os << "Finally Statement" << endl;
    418         os << indent << "... with block:" << endl << indent+1;
    419         block->print( os, indent+1 );
     428        os << indent << "... with block:" << endl << indent + 1;
     429        block->print( os, indent + 1 );
    420430}
    421431
    … …  
    429439}
    430440
    431 void SuspendStmt::print( std::ostream & os, Indenter indent ) const {
     441void SuspendStmt::print( ostream & os, Indenter indent ) const {
    432442        os << "Suspend Statement";
    433443        switch (type) {
    … …  
    486496}
    487497
    488 void WaitForStmt::print( std::ostream & os, Indenter indent ) const {
     498void WaitForStmt::print( ostream & os, Indenter indent ) const {
    489499        os << "Waitfor Statement" << endl;
    490500        indent += 1;
    … …  
    521531
    522532
    523 WithStmt::WithStmt( const std::list< Expression * > & exprs, Statement * stmt ) : Declaration("", noStorageClasses, LinkageSpec::Cforall), exprs( exprs ), stmt( stmt ) {}
     533WithStmt::WithStmt( const list< Expression * > & exprs, Statement * stmt ) : Declaration("", noStorageClasses, LinkageSpec::Cforall), exprs( exprs ), stmt( stmt ) {}
    524534WithStmt::WithStmt( const WithStmt & other ) : Declaration( other ), stmt( maybeClone( other.stmt ) ) {
    525535        cloneAll( other.exprs, exprs );
    … …  
    530540}
    531541
    532 void WithStmt::print( std::ostream & os, Indenter indent ) const {
     542void WithStmt::print( ostream & os, Indenter indent ) const {
    533543        os << "With statement" << endl;
    534544        os << indent << "... with expressions: " << endl;
    535         printAll( exprs, os, indent+1 );
    536         os << indent << "... with statement:" << endl << indent+1;
    537         stmt->print( os, indent+1 );
    538 }
    539 
    540 
    541 NullStmt::NullStmt( const std::list<Label> & labels ) : Statement( labels ) {
    542 }
    543 
    544 void NullStmt::print( std::ostream & os, Indenter indent ) const {
     545        printAll( exprs, os, indent + 1 );
     546        os << indent << "... with statement:" << endl << indent + 1;
     547        stmt->print( os, indent + 1 );
     548}
     549
     550
     551NullStmt::NullStmt( const list<Label> & labels ) : Statement( labels ) {
     552}
     553
     554void NullStmt::print( ostream & os, Indenter indent ) const {
    545555        os << "Null Statement" << endl;
    546556        Statement::print( os, indent );
    … …  
    558568}
    559569
    560 void ImplicitCtorDtorStmt::print( std::ostream & os, Indenter indent ) const {
     570void ImplicitCtorDtorStmt::print( ostream & os, Indenter indent ) const {
    561571        os << "Implicit Ctor Dtor Statement" << endl;
    562572        os << indent << "... with Ctor/Dtor: ";
    563         callStmt->print( os, indent+1);
     573        callStmt->print( os, indent + 1);
    564574        os << endl;
    565575}
    566576
    567 MutexStmt::MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs )
     577MutexStmt::MutexStmt( Statement * stmt, const list<Expression *> mutexObjs )
    568578        : Statement(), stmt( stmt ), mutexObjs( mutexObjs ) { }
    569579
    … …  
    577587}
    578588
    579 void MutexStmt::print( std::ostream & os, Indenter indent ) const {
     589void MutexStmt::print( ostream & os, Indenter indent ) const {
    580590        os << "Mutex Statement" << endl;
    581591        os << indent << "... with Expressions: " << endl;
    582592        for (auto * obj : mutexObjs) {
    583                 os << indent+1;
    584                 obj->print( os, indent+1);
     593                os << indent + 1;
     594                obj->print( os, indent + 1);
    585595                os << endl;
    586596        }
    587         os << indent << "... with Statement: " << endl << indent+1;
    588         stmt->print( os, indent+1 );
     597        os << indent << "... with Statement: " << endl << indent + 1;
     598        stmt->print( os, indent + 1 );
    589599}
    590600

  • src/SynTree/Statement.h

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Jan 10 14:13:24 2020
    13 // Update Count     : 85
     12// Last Modified On : Wed Feb  2 20:15:30 2022
     13// Update Count     : 98
    1414//
    1515
    … …  
    107107        std::list<Label> gotolabels;
    108108
    109         AsmStmt( bool voltile, Expression * instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
     109        AsmStmt( bool voltile, Expression * instruction, const std::list<Expression *> output, const std::list<Expression *> input, const std::list<ConstantExpr *> clobber, const std::list<Label> gotolabels );
    110110        AsmStmt( const AsmStmt & other );
    111111        virtual ~AsmStmt();
    … …  
    148148  public:
    149149        Expression * condition;
    150         Statement * thenPart;
    151         Statement * elsePart;
     150        Statement * then;
     151        Statement * else_;
    152152        std::list<Statement *> initialization;
    153153
    154         IfStmt( Expression * condition, Statement * thenPart, Statement * elsePart,
    155                         std::list<Statement *> initialization = std::list<Statement *>() );
     154        IfStmt( Expression * condition, Statement * then, Statement * else_,
     155                        const std::list<Statement *> initialization = std::list<Statement *>() );
    156156        IfStmt( const IfStmt & other );
    157157        virtual ~IfStmt();
    … …  
    160160        Expression * get_condition() { return condition; }
    161161        void set_condition( Expression * newValue ) { condition = newValue; }
    162         Statement * get_thenPart() { return thenPart; }
    163         void set_thenPart( Statement * newValue ) { thenPart = newValue; }
    164         Statement * get_elsePart() { return elsePart; }
    165         void set_elsePart( Statement * newValue ) { elsePart = newValue; }
     162        Statement * get_then() { return then; }
     163        void set_then( Statement * newValue ) { then = newValue; }
     164        Statement * get_else() { return else_; }
     165        void set_else( Statement * newValue ) { else_ = newValue; }
    166166
    167167        virtual IfStmt * clone() const override { return new IfStmt( *this ); }
    … …  
    225225};
    226226
    227 class WhileStmt : public Statement {
     227class WhileDoStmt : public Statement {
    228228  public:
    229229        Expression * condition;
    230230        Statement * body;
     231        Statement * else_;
    231232        std::list<Statement *> initialization;
    232233        bool isDoWhile;
    233234
    234         WhileStmt( Expression * condition, Statement * body, std::list<Statement *> & initialization, bool isDoWhile = false );
    235         WhileStmt( const WhileStmt & other );
    236         virtual ~WhileStmt();
     235        WhileDoStmt( Expression * condition, Statement * body, const std::list<Statement *> & initialization, bool isDoWhile = false );
     236        WhileDoStmt( Expression * condition, Statement * body, Statement * else_, const std::list<Statement *> & initialization, bool isDoWhile = false );
     237        WhileDoStmt( const WhileDoStmt & other );
     238        virtual ~WhileDoStmt();
    237239
    238240        Expression * get_condition() { return condition; }
    … …  
    243245        void set_isDoWhile( bool newValue ) { isDoWhile = newValue; }
    244246
    245         virtual WhileStmt * clone() const override { return new WhileStmt( *this ); }
     247        virtual WhileDoStmt * clone() const override { return new WhileDoStmt( *this ); }
    246248        virtual void accept( Visitor & v ) override { v.visit( this ); }
    247249        virtual void accept( Visitor & v ) const override { v.visit( this ); }
    … …  
    256258        Expression * increment;
    257259        Statement * body;
    258 
    259         ForStmt( std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr );
     260        Statement * else_;
     261
     262        ForStmt( const std::list<Statement *> initialization, Expression * condition = nullptr, Expression * increment = nullptr, Statement * body = nullptr, Statement * else_ = nullptr );
    260263        ForStmt( const ForStmt & other );
    261264        virtual ~ForStmt();
    … …  
    278281class BranchStmt : public Statement {
    279282  public:
    280         enum Type { Goto = 0, Break, Continue, FallThrough, FallThroughDefault };
     283        enum Type { Goto, Break, Continue, FallThrough, FallThroughDefault, BranchStmts };
    281284
    282285        // originalTarget kept for error messages.
    … …  
    357360        FinallyStmt * finallyBlock;
    358361
    359         TryStmt( CompoundStmt * tryBlock, std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = nullptr );
     362        TryStmt( CompoundStmt * tryBlock, const std::list<CatchStmt *> & handlers, FinallyStmt * finallyBlock = nullptr );
    360363        TryStmt( const TryStmt & other );
    361364        virtual ~TryStmt();
    … …  
    540543        std::list<Expression *> mutexObjs; // list of mutex objects to acquire
    541544
    542         MutexStmt( Statement * stmt, std::list<Expression *> mutexObjs );
     545        MutexStmt( Statement * stmt, const std::list<Expression *> mutexObjs );
    543546        MutexStmt( const MutexStmt & other );
    544547        virtual ~MutexStmt();

  • src/SynTree/SynTree.h

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:56:44 2021
    13 // Update Count     : 13
     12// Last Modified On : Tue Feb  1 09:22:33 2022
     13// Update Count     : 14
    1414//
    1515
    … …  
    4545class DirectiveStmt;
    4646class IfStmt;
    47 class WhileStmt;
     47class WhileDoStmt;
    4848class ForStmt;
    4949class SwitchStmt;

  • src/SynTree/Visitor.h

    r97c215f rf5a51db  
    1010// Created On       : Mon May 18 07:44:20 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Fri Mar 12 18:35:35 2021
    13 // Update Count     : 15
     12// Last Modified On : Tue Feb  1 09:26:57 2022
     13// Update Count     : 17
    1414//
    1515
    … …  
    6060        virtual void visit( IfStmt * node ) { visit( const_cast<const IfStmt *>(node) ); }
    6161        virtual void visit( const IfStmt * ifStmt ) = 0;
    62         virtual void visit( WhileStmt * node ) { visit( const_cast<const WhileStmt *>(node) ); }
    63         virtual void visit( const WhileStmt * whileStmt ) = 0;
     62        virtual void visit( WhileDoStmt * node ) { visit( const_cast<const WhileDoStmt *>(node) ); }
     63        virtual void visit( const WhileDoStmt * whileDoStmt ) = 0;
    6464        virtual void visit( ForStmt * node ) { visit( const_cast<const ForStmt *>(node) ); }
    6565        virtual void visit( const ForStmt * forStmt ) = 0;

  • src/Validate/module.mk

    r97c215f rf5a51db  
    1616
    1717SRC_VALIDATE = \
     18        Validate/Autogen.cpp \
     19        Validate/Autogen.hpp \
    1820        Validate/CompoundLiteral.cpp \
    1921        Validate/CompoundLiteral.hpp \

  • src/main.cc

    r97c215f rf5a51db  
    1010// Created On       : Fri May 15 23:12:02 2015
    1111// Last Modified By : Andrew Beach
    12 // Last Modified On : Tue Nov 30 10:25:00 2021
    13 // Update Count     : 659
     12// Last Modified On : Wed Jan 26 14:09:00 2022
     13// Update Count     : 670
    1414//
    1515
    … …  
    5555#include "ControlStruct/ExceptTranslate.h"  // for translateEHM
    5656#include "ControlStruct/FixLabels.hpp"      // for fixLabels
     57#include "ControlStruct/HoistControlDecls.hpp" //  hoistControlDecls
    5758#include "ControlStruct/Mutate.h"           // for mutate
    5859#include "GenPoly/Box.h"                    // for box
    … …  
    7374#include "SynTree/Visitor.h"                // for acceptAll
    7475#include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
     76#include "Validate/Autogen.hpp"             // for autogenerateRoutines
    7577#include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
    7678#include "Validate/CompoundLiteral.hpp"     // for handleCompoundLiterals
    … …  
    7880#include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
    7981#include "Virtual/ExpandCasts.h"            // for expandCasts
    80 
    8182
    8283static void NewPass( const char * const name ) {
    … …  
    326327                PASS( "Validate-B", SymTab::validate_B( translationUnit ) );
    327328                PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
    328                 PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
    329329
    330330                CodeTools::fillLocations( translationUnit );
    331331
    332332                if( useNewAST ) {
     333                        PASS( "Apply Concurrent Keywords", Concurrency::applyKeywords( translationUnit ) );
     334                        PASS( "Forall Pointer Decay", SymTab::decayForallPointers( translationUnit ) );
     335                        CodeTools::fillLocations( translationUnit );
     336
    333337                        if (Stats::Counters::enabled) {
    334338                                ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
    … …  
    338342
    339343                        forceFillCodeLocations( transUnit );
     344
     345                        // Must happen before autogen routines are added.
     346                        PASS( "Hoist Control Declarations", ControlStruct::hoistControlDecls( transUnit ) );
     347
     348                        // Must be after enum and pointer decay.
     349                        // Must be before compound literals.
     350                        PASS( "Generate Autogen Routines", Validate::autogenerateRoutines( transUnit ) );
    340351
    341352                        PASS( "Implement Mutex", Concurrency::implementMutex( transUnit ) );
    … …  
    404415                        // Currently not working due to unresolved issues with UniqueExpr
    405416                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
     417
     418                        PASS( "Translate Tries" , ControlStruct::translateTries( transUnit ) );
     419
    406420                        translationUnit = convert( move( transUnit ) );
    407421                } else {
     422                        PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
    408423                        PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
    409424                        PASS( "Validate-F", SymTab::validate_F( translationUnit ) );
    … …  
    469484
    470485                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
     486
     487                        PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
    471488                }
    472489
    473                 PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
     490               
    474491
    475492                PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );

  • tests/concurrent/.expect/ctor-check.txt

    r97c215f rf5a51db  
    22?{}: function
    33... with parameters
    4   lvalue reference to instance of struct Empty with body
     4  this: lvalue reference to instance of struct Empty with body
    55... returning nothing
    66 with body

  • tests/concurrent/mutexstmt/.expect/locks.txt

    r97c215f rf5a51db  
    33Start Test: multi lock deadlock/mutual exclusion
    44End Test: multi lock deadlock/mutual exclusion
     5Start Test: single scoped lock mutual exclusion
     6End Test: single scoped lock mutual exclusion
     7Start Test: multi scoped lock deadlock/mutual exclusion
     8End Test: multi scoped lock deadlock/mutual exclusion

  • tests/concurrent/mutexstmt/locks.cfa

    r97c215f rf5a51db  
    5959}
    6060
     61thread T_Mutex_Scoped {};
    6162
     63void main( T_Mutex_Scoped & this ) {
     64        for (unsigned int i = 0; i < num_times; i++) {
     65                {
     66                        scoped_lock(single_acquisition_lock) s{m1};
     67                        count++;
     68                }
     69                {
     70                        scoped_lock(single_acquisition_lock) s{m1};
     71                        assert(!insideFlag);
     72                        insideFlag = true;
     73                        assert(insideFlag);
     74                        insideFlag = false;
     75                }
     76        }
     77}
     78
     79thread T_Multi_Scoped {};
     80
     81void main( T_Multi_Scoped & this ) {
     82        for (unsigned int i = 0; i < num_times; i++) {
     83                {
     84                        scoped_lock(single_acquisition_lock) s{m1};
     85                        assert(!insideFlag);
     86                        insideFlag = true;
     87                        assert(insideFlag);
     88                        insideFlag = false;
     89                }
     90                {
     91                        scoped_lock(single_acquisition_lock) s1{m1};
     92                        scoped_lock(single_acquisition_lock) s2{m2};
     93                        scoped_lock(single_acquisition_lock) s3{m3};
     94                        scoped_lock(single_acquisition_lock) s4{m4};
     95                        scoped_lock(single_acquisition_lock) s5{m5};
     96                        assert(!insideFlag);
     97                        insideFlag = true;
     98                        assert(insideFlag);
     99                        insideFlag = false;
     100                }
     101                {
     102                        scoped_lock(single_acquisition_lock) s1{m1};
     103                        scoped_lock(single_acquisition_lock) s3{m3};
     104                        assert(!insideFlag);
     105                        insideFlag = true;
     106                        assert(insideFlag);
     107                        insideFlag = false;
     108                }
     109                {
     110                        scoped_lock(single_acquisition_lock) s1{m1};
     111                        scoped_lock(single_acquisition_lock) s2{m2};
     112                        scoped_lock(single_acquisition_lock) s4{m4};
     113                        assert(!insideFlag);
     114                        insideFlag = true;
     115                        assert(insideFlag);
     116                        insideFlag = false;
     117                }
     118                {
     119                        scoped_lock(single_acquisition_lock) s1{m1};
     120                        scoped_lock(single_acquisition_lock) s3{m3};
     121                        scoped_lock(single_acquisition_lock) s4{m4};
     122                        scoped_lock(single_acquisition_lock) s5{m5};
     123                        assert(!insideFlag);
     124                        insideFlag = true;
     125                        assert(insideFlag);
     126                        insideFlag = false;
     127                }
     128        }
     129}
     130
     131int num_tasks = 10;
    62132int main() {
    63133        processor p[10];
    … …  
    67137                T_Mutex t[10];
    68138        }
     139        assert(count == num_tasks * num_times);
    69140        printf("End Test: single lock mutual exclusion\n");
    70141        printf("Start Test: multi lock deadlock/mutual exclusion\n");
    … …  
    73144        }
    74145        printf("End Test: multi lock deadlock/mutual exclusion\n");
     146       
     147        count = 0;
     148        printf("Start Test: single scoped lock mutual exclusion\n");
     149        {
     150                T_Mutex_Scoped t[10];
     151        }
     152        assert(count == num_tasks * num_times);
     153        printf("End Test: single scoped lock mutual exclusion\n");
     154        printf("Start Test: multi scoped lock deadlock/mutual exclusion\n");
     155        {
     156                T_Multi_Scoped t[10];
     157        }
     158        printf("End Test: multi scoped lock deadlock/mutual exclusion\n");     
    75159}

  • tests/concurrent/preempt.cfa

    r97c215f rf5a51db  
     1#include <clock.hfa>
     2#include <fstream.hfa>
    13#include <kernel.hfa>
    24#include <thread.hfa>
    … …  
    2123extern void __cfaabi_check_preemption();
    2224
    23 static volatile int counter = 0;
     25static struct {
     26        volatile int counter;
     27        volatile Time prev;
     28        Duration durations[6];
     29} globals;
    2430
    2531thread worker_t {
    2632        int value;
     33        unsigned long long spin;
    2734};
    2835
    2936void ?{}( worker_t & this, int value ) {
    3037        this.value = value;
     38        this.spin = 0;
    3139}
    3240
    3341void main(worker_t & this) {
    34         while(TEST(counter < N)) {
     42        while(TEST(globals.counter < N)) {
     43                if(this.spin > 50_000_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
    3544                __cfaabi_check_preemption();
    36                 if( (counter % 7) == this.value ) {
     45                if( (globals.counter % 7) == this.value ) {
    3746                        __cfaabi_check_preemption();
    38                         int next = __atomic_add_fetch( &counter, 1, __ATOMIC_SEQ_CST );
     47                        #if !defined(TEST_LONG)
     48                                Time now = timeHiRes();
     49                                Duration diff = now - globals.prev;
     50                                globals.prev = now;
     51                        #endif
     52                        int next = __atomic_add_fetch( &globals.counter, 1, __ATOMIC_SEQ_CST );
    3953                        __cfaabi_check_preemption();
    40                         if( (next % 100) == 0 ) printf("%d\n", (int)next);
     54                        if( (next % 100) == 0 ) {
     55                                #if !defined(TEST_LONG)
     56                                        unsigned idx = next / 100;
     57                                        if (idx >= 6) abort | "Idx from next is invalid: " | idx | "vs" | next;
     58                                        globals.durations[idx] = diff;
     59                                        if(diff > 12`s) serr | "Duration suspiciously large:" | diff;
     60                                #endif
     61                                printf("%d\n", (int)next);
     62
     63                        }
    4164                        __cfaabi_check_preemption();
     65                        this.spin = 0;
    4266                }
    4367                __cfaabi_check_preemption();
    4468                KICK_WATCHDOG;
     69                this.spin++;
    4570        }
    4671}
    … …  
    4873int main(int argc, char* argv[]) {
    4974        processor p;
     75        globals.counter = 0;
     76        globals.durations[0] = 0;
     77        globals.durations[1] = 0;
     78        globals.durations[2] = 0;
     79        globals.durations[3] = 0;
     80        globals.durations[4] = 0;
     81        globals.durations[5] = 0;
    5082        {
     83                globals.prev = timeHiRes();
    5184                worker_t w0 = 0;
    5285                worker_t w1 = 1;

  • tests/include/.expect/includes.nast.txt

    r97c215f rf5a51db  
    1 include/includes.cfa:154:25: warning: Compiled
     1include/includes.cfa:153:25: warning: Compiled

  • tests/include/includes.cfa

    r97c215f rf5a51db  
    1010// Created On       : Wed May 27 17:56:53 2015
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sat Jun  5 10:06:46 2021
    13 // Update Count     : 751
     12// Last Modified On : Thu Feb  3 22:06:07 2022
     13// Update Count     : 774
    1414//
    1515
    … …  
    1818#endif // __CFA__
    1919
     20#if 1
    2021//#define _GNU_SOURCE
    2122#include <aio.h>
    … …  
    4041#include <errno.h>
    4142#include <error.h>
    42 //#include <eti.h>                                                                              // may not be installed, comes with ncurses
     43//#include <eti.h>                                                                              // may not be installed, comes with ncurses
    4344#include <execinfo.h>
    4445#include <expat.h>
    … …  
    4950#include <fmtmsg.h>
    5051#include <fnmatch.h>
    51 //#include <form.h>                                                                             // may not be installed, comes with ncurses
     52//#include <form.h>                                                                             // may not be installed, comes with ncurses
    5253#include <fstab.h>
    5354#include <fts.h>
    … …  
    7778#include <mcheck.h>
    7879#include <memory.h>
    79 //#include <menu.h>                                                                             // may not be installed, comes with ncurses
     80//#include <menu.h>                                                                             // may not be installed, comes with ncurses
    8081#include <mntent.h>
    8182#include <monetary.h>
    8283#include <mqueue.h>
    83 //#include <ncurses_dll.h>                                                                      // may not be installed, comes with ncurses
     84//#include <ncurses_dll.h>                                                              // may not be installed, comes with ncurses
    8485#include <netdb.h>
    8586#include <nl_types.h>
    8687#include <nss.h>
    8788#include <obstack.h>
    88 //#include <panel.h>                                                                            // may not be installed, comes with ncurses
     89//#include <panel.h>                                                                            // may not be installed, comes with ncurses
    8990#include <paths.h>
    9091#include <poll.h>
    … …  
    117118#include <syslog.h>
    118119#include <tar.h>
    119 //#include <term.h>                                                                             // may not be installed, comes with ncurses
    120 //#include <termcap.h>                                                                          // may not be installed, comes with ncurses
     120//#include <term.h>                                                                             // may not be installed, comes with ncurses
     121//#include <termcap.h>                                                                  // may not be installed, comes with ncurses
    121122#include <termio.h>
    122123#include <termios.h>
    … …  
    130131#include <ucontext.h>
    131132#include <ulimit.h>
    132 //#include <unctrl.h>                                                                           // may not be installed, comes with ncurses
     133//#include <unctrl.h>                                                                           // may not be installed, comes with ncurses
    133134#include <unistd.h>
    134135#include <utime.h>
    … …  
    143144#include <wctype.h>
    144145#include <wordexp.h>
    145 
    146 #if 0
    147146#endif // 0
    148147
    … …  
    151150#endif // __CFA__
    152151
    153 int main( int argc, char const *argv[] ) {
    154     #pragma GCC warning "Compiled"                      // force non-empty .expect file, NO TABS!!!
     152int main( int argc, char const * argv[] ) {
     153    #pragma GCC warning "Compiled"                                                      // force non-empty .expect file, NO TABS!!!
    155154}
    156155

  • tools/auto-complete.md

    r97c215f rf5a51db  
    3232
    3333### Zsh
     34
     351 - Add the following somewhere:
     36    #compdef test.py
     37
     38    _test_py() {
     39        local -a options
     40        options=$($words[1] --list-comp)
     41        _alternative "files:filenames:($options)"
     42    }
     43
     44    _test_py "$@"
     45
     462 - Add the path to that file to the "fpath" environment variable.
     47
     483 - In ~/.zshrc add
     49    autoload -U compinit
     50    compinit
     51
     52*How it works:* I don't know ;P
     53
     54
Note: See TracChangeset for help on using the changeset viewer.