Changeset c28ea4e

Jenkins/FullBuild

-              r4b30e8cc
+              rc28ea4e
                                 parallel (
                                         clang_x86: { trigger_build( 'gcc-8',   'x86' ) },
                                         gcc_5_x86: { trigger_build( 'gcc-7',   'x86' ) },
+                                        gcc_8_x86: { trigger_build( 'gcc-8',   'x86' ) },
+                                        gcc_7_x86: { trigger_build( 'gcc-7',   'x86' ) },
                                         gcc_6_x86: { trigger_build( 'gcc-6',   'x86' ) },
                                         gcc_9_x64: { trigger_build( 'gcc-9',   'x64' ) },

Jenkinsfile

-              r4b30e8cc
+              rc28ea4e
+                        }
+                        sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} AR=gcc-ar RANLIB=gcc-ranlib ${targets} --quiet --prefix=${BuildDir}"
+                        ast = Settings.NewAST ? "--enable-new-ast" : "--disable-new-ast"
+                        sh "${SrcDir}/configure CXX=${Settings.Compiler.CXX} CC=${Settings.Compiler.CC} ${Settings.Architecture.flags} AR=gcc-ar RANLIB=gcc-ranlib ${targets} ${ast} --quiet --prefix=${BuildDir}"
                         // Configure libcfa
 …
         public final CC_Desc Compiler
         public final Arch_Desc Architecture
+        public final Boolean NewAST
         public final Boolean RunAllTests
         public final Boolean RunBenchmark
 …
                 this.IsSandbox          = (branch == "jenkins-sandbox")
+                this.NewAST             = param.NewAST
                 this.RunAllTests        = param.RunAllTests
                 this.RunBenchmark       = param.RunBenchmark
 …
                                 ],                                                                                              \
                                 [$class: 'BooleanParameterDefinition',                                                  \
+                                        description: 'If true, build compiler using new AST',           \
+                                        name: 'NewAST',                                                                         \
+                                        defaultValue: false,                                                            \
+                                ],                                                                                              \
+                                [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If false, only the quick test suite is ran',              \
                                         name: 'RunAllTests',                                                            \
                                         defaultValue: false,                                                            \
                                 ],                                                                                              \
+                                ],
                                 [$class: 'BooleanParameterDefinition',                                                  \
                                         description: 'If true, jenkins also runs benchmarks',           \

configure.ac

-              r4b30e8cc
+              rc28ea4e
 # New AST toggling support
 AH_TEMPLATE([CFA_USE_NEW_AST],[Sets whether or not to use the new-ast, this is adefault value and can be overrided by --old-ast and --new-ast])
+DEFAULT_NEW_AST="False"
 AC_ARG_ENABLE(new-ast,
         [  --enable-new-ast     whether or not to use new ast as the default AST algorithm],
         [case "${enableval}" in
                 yes) newast=true ;;
                 no)  newast=false ;;
+                yes) newast=true ; DEFAULT_NEW_AST="True"  ;;
+                no)  newast=false; DEFAULT_NEW_AST="False" ;;
                 *) AC_MSG_ERROR([bad value ${enableval} for --enable-new-ast]) ;;
         esac],[newast=false])
 AC_DEFINE_UNQUOTED([CFA_USE_NEW_AST], $newast)
+AC_SUBST(DEFAULT_NEW_AST)
 #==============================================================================

doc/papers/concurrency/mail2

-              r4b30e8cc
+              rc28ea4e
 Date: Wed, 26 Jun 2019 20:12:38 +0000
 From: Aaron Thomas <onbehalfof@manuscriptcentral.com>
 …
 Software: Practice and Experience Editorial Office
+Date: Thu, 15 Oct 2020 13:48:52 +0000
+From: Richard Jones <onbehalfof@manuscriptcentral.com>
+Reply-To: R.E.Jones@kent.ac.uk
+To: tdelisle@uwaterloo.ca, pabuhr@uwaterloo.ca
+Subject: Software: Practice and Experience - Decision on Manuscript ID
+ SPE-19-0219.R3
+-Oct-2020
+Dear Dr Buhr,
+It is a pleasure to accept your manuscript entitled "Advanced Control-flow and Concurrency in Cforall" in its current form for publication in Software: Practice and Experience.
+Please note although the manuscript is accepted the files will now be checked to ensure that everything is ready for publication, and you may be contacted if final versions of files for publication are required.
+Your article cannot be published until the publisher has received the appropriate signed license agreement. Within the next few days the corresponding author will receive an email from Wiley's Author Services system which will ask them to log in and will present them with the appropriate license for completion.
+Thank you for your fine contribution.
+Sincerely,
+Richard
+Prof. Richard Jones
+Editor, Software: Practice and Experience
+R.E.Jones@kent.ac.uk
+P.S. - You can help your research get the attention it deserves! Check out Wiley's free Promotion Guide for best-practice recommendations for promoting your work at www.wileyauthors.com/eeo/guide. And learn more about Wiley Editing Services which offers professional video, design, and writing services to create shareable video abstracts, infographics, conference posters, lay summaries, and research news stories for your research at www.wileyauthors.com/eeo/promotion.
+This journal accepts artwork submissions for Cover Images. This is an optional service you can use to help increase article exposure and showcase your research. For more information, including artwork guidelines, pricing, and submission details, please visit the Journal Cover Image page at www.wileyauthors.com/eeo/covers. If you want help creating an image, Wiley Editing Services offers a professional cover image design service that creates eye-catching images, ready to be showcased on the journal cover at www.wileyauthors.com/eeo/design.
+Date: Fri, 16 Oct 2020 12:44:42 +0000
+From: Mayank Roy Chowdhury <onbehalfof@manuscriptcentral.com>
+Reply-To: speoffice@wiley.com
+To: pabuhr@uwaterloo.ca
+Subject: Manuscript Accepted - Please submit final updates to SPE-19-0219.R3 [email ref: ENR-AW-1-c]
+-Oct-2020
+Dear Dr. Buhr,
+Manuscript id: SPE-19-0219.R3
+Manuscript title: Advanced Control-flow and Concurrency in Cforall
+Although your manuscript has been accepted for publication it is now being returned to your author center for you to review and make any final adjustments or corrections prior to production and publication.
+Any special instructions will be listed below:
+) Funding Information added in ScholorOne but missing in main document, Kindly add the Funding information in main document.
+) Please provide the clean version of the manuscript without any highlights or tracked changes.
+) Kindly check and make sure citations for all figures and Tables are present in the main document
+Please now log back into your Scholar One Author Center and click on the "Manuscripts Accepted for First Look" queue. In order to update the submission, click on the "submit updated manuscript" link in the "Actions" column and follow the steps as you would during a manuscript submission process.
+On the File Upload screen please upload the FINAL versions of all the files, including print quality image files. For information about image quality requirements, please refer to the guidelines at https://authorservices.wiley.com/asset/photos/electronic_artwork_guidelines.pdf.
+Instructions for uploading replacement files:
+. On the "File Upload" step, click on the "edit" button for the file you wish to replace.
+. In the "Upload a later version" section, browse to locate the replacement final version.
+. Add any comments concerning the replacement (e.g. "high res image").
+. Select whether the new file is a minor or major version (we suggest you select minor version)
+. Click upload.
+. Click 'Submit' when all the files have been uploaded and you will receive an automated email to say that submission is successful.
+Please submit your updates within the next 7 days to ensure there are no unnecessary delays in production.
+Sincerely,
+Software: Practice and Experience Editorial Office
+From: SPE Office <speoffice@wiley.com>
+To: "Peter A. Buhr" <pabuhr@uwaterloo.ca>
+Subject: Re: Manuscript Accepted - Please submit final updates to SPE-19-0219.R3 [email ref: ENR-AW-1-c]
+Date: Mon, 19 Oct 2020 17:04:24 +0000
+Dear Dr. Buhr,
+Thank you very much for contacting the Editorial Office.
+I would like to let you know that the files has been found in order and moved to production.
+Plesae let me know for further assistance in this regard.
+Best Regards
+Mayank Roy Chowdhury
+Editorial Assistant
+Software practice and Experience
+________________________________
+From: Peter A. Buhr <pabuhr@uwaterloo.ca>
+Sent: Sunday, October 18, 2020 2:00 PM
+To: SPE Office <speoffice@wiley.com>
+Cc: Thierry Delisle <tdelisle@uwaterloo.ca>
+Subject: Re: Manuscript Accepted - Please submit final updates to SPE-19-0219.R3 [email ref: ENR-AW-1-c]
+       This is an external email.
+    Mayank Roy Chowdhury <onbehalfof@manuscriptcentral.com> writes:
+    Instructions for uploading replacement files:
+. On the "File Upload" step, click on the "edit" button for the file you wish to replace.
+. In the "Upload a later version" section, browse to locate the replacement final version.
+. Add any comments concerning the replacement (e.g. "high res image").
+. Select whether the new file is a minor or major version (we suggest you select minor version)
+. Click upload.
+. Click 'Submit' when all the files have been uploaded and you will receive an automated email to say that submission is successful.
+There was no "edit" button on the "File Upload" page, so I just upload the
+final version of the PDF and source files using the mechanism on the "File
+Upload" page and submitted that.
+Date: Tue, 20 Oct 2020 13:28:37 +0530
+To: "Dr. Peter Buhr" <pabuhr@uwaterloo.ca>
+From: jpcms@spi-global.com
+Subject: Information: Production Editor Contact Software:Practice and Experience  | Advanced Control-flow and Concurrency in C A
+Dear Dr. Peter Buhr,
+We are in the process of preparing "Advanced Control-flow and Concurrency in C A" for publication. Your production editor, Joel Pacaanas, will support you and your article throughout the process.
+Please get in touch with your Production Editor at SPEproofs@wiley.com;EllaMae.Navor@spi-global.com if you have any questions.
+Sincerely,
+Booking-in Team,
+On behalf of Wiley
+Article ID: SPE_2925
+Article DOI: 10.1002/SPE.2925
+Date: Tue, 20 Oct 2020 10:33:04 +0000
+From: <cs-author@wiley.com>
+To: <pabuhr@uwaterloo.ca>
+Subject: In Production: Your article accepted in Software: Practice and Experience
+Dear Peter Buhr,
+Article ID: SPE2925
+Article DOI: 10.1002/spe.2925
+Internal Article ID: 16922213
+Article: Advanced Control-flow and Concurrency in C A
+Journal: Software: Practice and Experience
+Congratulations on the acceptance of your article for publication in Software: Practice and Experience.
+Your article has been received and the production process is now underway. We look forward to working with you and publishing your article. Using Wiley Author Services, you can track your article's progress.
+Please click below to login - if you are using a different email address than this one, you will need to manually assign this article to your Dashboard (see https://hub.wiley.com/docs/support/assigning-a-missing-article-to-my-dashboard-DOC-11871?utm_source=new%20user%20invitation&utm_medium=email How do I assign a missing article to My Dashboard?):
+https://authorservices.wiley.com/index.html#login?campaign=email_invitation-new
+If applicable, a list of available actions will appear below - check out your Author Services Dashboard for all actions related to your articles.
+Sign your license agreement (REQUIRED)  -- you will receive an email when this task is ready on your dashboard. Track your article's progress to publicationAccess your published articleInvite colleagues to view your published article
+If you need any assistance, please click http://www.wileyauthors.com/help?utm_source=new%20user%20invitation&utm_medium=email here to view our Help section.
+Sincerely,
+Wiley Author Services
+P.S. - Some journals accept artwork submissions for Cover Images. This is an optional service you can use to help increase article exposure and showcase your research. Pricing and placement options vary by journal. For more information, including artwork guidelines, pricing, and submission details, please visit the https://authorservices.wiley.com/author-resources/Journal-Authors/Promotion/journal-cover-image.html?utm_source=as&utm_medium=email&utm_term=invitation_msg&utm_content=covers&utm_campaign=2019feb?campaign=email_invitation-new" target=_blank">Journal Cover Image page. If you want help creating an image, Wiley Editing Services offers a professional https://wileyeditingservices.com/en/article-promotion/cover-image-design.html?utm_source=as&utm_medium=email&utm_term=ie&utm_content=cid&utm_campaign=prodops" target=_blank">Cover Image Design service that creates eye-catching images, ready to be showcased on the journal cover.
+Date: Thu, 22 Oct 2020 20:21:49 +0000
+From: <cs-author@wiley.com>
+To: <pabuhr@uwaterloo.ca>
+Subject: You have actions to complete in Author Services
+Dear Peter Buhr,
+Article ID: SPE2925
+Article DOI: 10.1002/spe.2925
+Internal Article ID: 16922213
+Article: Advanced Control-flow and Concurrency in C A
+Journal: Software: Practice and Experience
+For the above article, you have the following open tasks:
+Sign your license agreement in order to publish your article. Simply click the Sign License button on your https://authorservices.wiley.com?campaign=email_license-notice1">Wiley Author Services Dashboard.
+Need any help? Please visit our https://authorsupport.wiley.com/s/">Author Support Center.
+Sincerely,
+Wiley Author Services
+Date: Thu, 22 Oct 2020 23:13:07 +0000
+From: <cs-author@wiley.com>
+To: <pabuhr@uwaterloo.ca>
+Subject: License was successfully submitted! Thank you!
+Dear Peter Buhr,
+Article ID: SPE2925
+Article DOI: 10.1002/spe.2925
+Internal Article ID: 16922213
+Article: Advanced Control-flow and Concurrency in C A
+Journal: Software: Practice and Experience
+You've successfully completed license signing for your article - thank you! You can view your signed agreement at any time by visiting your https://authorservices.wiley.com?campaign=email_license-confirm">Wiley Author Services Dashboard.
+Sincerely,
+Wiley Author Services

doc/proposals/vtable.md

-              r4b30e8cc
+              rc28ea4e
 possibly like the one used to create the assertion.
+### Extension: Associated Types Use
+If the `associated_types.md` proposal is accepted the following trait could
+be added:
+    trait is_virtual(dtype T) {
+        dtype table;
+        // An example assertion:
+        const table & get_virtual_table(T &);
+    }
+There may be more assertions but there has to be at least one way to find
+the (possibly default) virtual table. It is required to construct instances
+of the type.
+Without the assotiated type it would look like this:
+    trait is_virtual(dtype T, dtype table) {
+        const table & get_virtual_table(T &);
+    }
+Which is just a little bit longer to use but becomes more problematic if the
+user has to explicately provide the table's name as it doesn't really have its
+own type name. If it does it is probably mangled.
 ### Virtual Tables as Types
 Here we consider encoding plus the implementation of functions on it to be a

doc/theses/andrew_beach_MMath/thesis-frontpgs.tex

-              r4b30e8cc
+              rc28ea4e
 % TITLE PAGE
 %----------------------------------------------------------------------
+% Slowly generalizing.
+\ethesissetup{
+  author=Pat Neugraad,%
+  title={University of Waterloo E-Thesis Template for \LaTeX},
+  degree=phd,%
+  program=Zoology,%
+}
 \pagestyle{empty}
 …
         \vspace*{1.0cm}
+        \Huge
+        {\bf University of Waterloo E-Thesis Template for \LaTeX }
+        \vspace*{1.0cm}
+        \normalsize
+        {\Huge\bf \eprint{title}}
+        \vspace*{1.0cm}
         by \\
         \vspace*{1.0cm}
+        \Large
+        Pat Neugraad \\
+        {\Large \eprint{author}} \\
         \vspace*{3.0cm}
-        \normalsize
         A thesis \\
         presented to the University of Waterloo \\
         in fulfillment of the \\
         thesis requirement for the degree of \\
         Doctor of Philosophy \\
+        \eprint{degree} \\
         in \\
         Zoology \\
+        \eprint{program} \\
         \vspace*{2.0cm}
 …
         \vspace*{1.0cm}
         \copyright\ Pat Neugraad 2017 \\
+        \copyright{} \eprint{author} 2017 \\
         \end{center}
 \end{titlepage}

doc/theses/andrew_beach_MMath/uw-ethesis.cls

-              r4b30e8cc
+              rc28ea4e
+%
 % Exported Names:
+%   \ethesissetup{<key-value-pairs>}
+%     Preforms set-up (or a reconfiguration) of the document class. See the
+%     Set-Up Keys section for the keys that may be passed in. Use commas to
+%     seperate key-value-pairs.
+%
 %   \ifformat{<format>}{<true>}{<false>}
 %     If the document's format is <format> than expands to <true> otherwise
 …
 %     initial setup depends on the document format but they can be overriden
 %     with options in <setup> (set hyperref's \hypersetup for details).
+%
+%   \eprint{<key>}
+%     Expands to a human readable value tracked by the ethesis class. This
+%     can be used to retreave and format values set during set up.
+%
+% Set-Up Keys:
+%   author=<text>
+%   title=<text>
+%   program=<text>
+%   subject=<text>
+%   keywords=<text>
+%   degree=masters|phd
+%   faculty=ahs|arts|eng|env|math|sci
 \NeedsTeXFormat{LaTeX2e}
 \ProvidesClass{uw-ethesis}[2020/03/24 v0.1 UW-eThesis Template Document Class]
+\ProvidesClass{uw-ethesis}[2020/10/25 v0.2 UW-eThesis Template Document Class]
 \RequirePackage{etoolbox}
+\RequirePackage{xkeyval}
 % Requested Format:
 \newrobustcmd*{\ethesis@format}{digital}
 \DeclareOption{print}{\renewrobustcmd*{\ethesis@format}{print}}
 \DeclareOption{digital}{\renewrobustcmd*{\ethesis@format}{digital}}
+\newrobustcmd*{\ethesis@@format}{digital}
+\DeclareOption{print}{\renewrobustcmd*{\ethesis@@format}{print}}
+\DeclareOption{digital}{\renewrobustcmd*{\ethesis@@format}{digital}}
 \ProcessOptions\relax
 …
 % a recto page. This will often require an empty verso (left-hand side) page
 % that should not have the page number printed on it.
 \let\origdoublepage\cleardoublepage
+\let\ethesis@origdoublepage\cleardoublepage
 \newcommand{\clearemptydoublepage}{%
   \clearpage{\pagestyle{empty}\origdoublepage}}
+  \clearpage{\pagestyle{empty}\ethesis@origdoublepage}}
 \let\cleardoublepage\clearemptydoublepage
 …
 \renewcommand*{\bibname}{References}
+% Configurations
+\def\setThesisTitle#1{\newrobustcmd*{\ethesis@title}{#1}}
+\def\setThesisAuthor#1{\newrobustcmd*{\ethesis@author}{#1}}
+\def\setThesisSubject#1{\newrobustcmd*{\ethesis@subject}{#1}}
+\def\setThesisKeywords#1{\newrobustcmd*{\ethesis@keywords}{#1}}
+\newrobustcmd*\ethesissetup[1]{\setkeys{ethesis}{#1}}
+\define@cmdkeys{ethesis}[ethesis@@]{%
+  author,title,program,subject,keywords}
+\define@choicekey{ethesis}{degree}{masters,phd}{\def\ethesis@@degree{#1}}
+\define@choicekey{ethesis}{faculty}{ahs,arts,eng,env,math,sci}%
+  {\def\ethesis@@faculty{#1}}
+\newrobustcmd*\eprint[1]{
+  \ifcsdef{ethesis@long#1}{\csuse{ethesis@long#1}}{%
+    \ifcsdef{ethesis@@#1}{\csuse{ethesis@@#1}}{%
+      % ERROR: (Check for a way to emit an actual error.)
+      [UW-eThesis doesn't know how to print: #1 ]
+    }
+  }
+}
+\newrobustcmd*\ethesis@longdegree{%
+  \ifdefstring{\ethesis@@degree}{phd}{Doctor of Philosophy}{Masters}}
 % Includes the hyperref package loading a number of defaults.
 …
     pdfstartview={FitH},    % Fits the width of the page to the window.
+  }
   \ifdef{\ethesis@title}{\hypersetup{pdftitle={\ethesis@title}}}{}
   \ifdef{\ethesis@author}{\hypersetup{pdfauthor={\ethesis@author}}}{}
   \ifdef{\ethesis@subject}{\hypersetup{pdfsubject={\ethesis@subject}}}{}
   \ifdef{\ethesis@keywords}{\hypersetup{pdfkeywords={\ethesis@keywords}}}{}
+  \ifdef{\ethesis@@title}{\hypersetup{pdftitle={\ethesis@@title}}}{}
+  \ifdef{\ethesis@@author}{\hypersetup{pdfauthor={\ethesis@@author}}}{}
+  \ifdef{\ethesis@@subject}{\hypersetup{pdfsubject={\ethesis@@subject}}}{}
+  \ifdef{\ethesis@@keywords}{\hypersetup{pdfkeywords={\ethesis@@keywords}}}{}
   \ifformat{print}{
     \hypersetup{

doc/theses/thierry_delisle_PhD/comp_II/presentation.tex

-              r4b30e8cc
+              rc28ea4e
         \miniframeson
+}
+\section{\CFA and Concurrency}
+\section{Concurrency and \CFA}
+\begin{frame}{Project}
+        \begin{center}
+                {\large Produce a scheduler for \CFA that is simple for programmers to understand and offers good general performance.}
+        \end{center}
+\end{frame}
+%------------------------------
 \begin{frame}{\CFA}
+        \CFA is a modern extension of C.
+        It adds to C : overloading, constructors/destructors, polymorphism, and much more.
+        ~\newline
+        For this project, the relevant aspects are:
+        \begin{itemize}
+                \item Fast and safe system language.
+                \item Threading.
+                \item Manual memory management.
+        \end{itemize}
 \end{frame}
 …
 \begin{frame}{Priority Scheduling}
         \begin{center}
         {\large
+                {\large
                         Runs all ready threads in group \textit{A} before any ready threads in group \textit{B}.
+                }
 …
         Processors begin busy for long periods can mean starvation.
+\end{frame}
+%------------------------------
+\begin{frame}{Scheduling in Practice: Summary}
+        \begin{columns}
+                \begin{column}{0.5\textwidth}
+                        \textbf{Feedback Scheduling}
+                        \newline
+                        \begin{itemize}
+                                \item Inappropriate for short lived threads.
+                                \item Overkill for cooperating threads.\newline
+                        \end{itemize}
+                \end{column}
+                \begin{column}{0.5\textwidth}
+                        \textbf{Priority Scheduling}
+                        \newline
+                        \begin{itemize}
+                                \item Allows lasting starvation.\newline
+                                \item Hard to reason about.\newline~\newline
+                        \end{itemize}
+                \end{column}
+        \end{columns}
+        ~\newline
+        ~\newline
+        \CFA would benefit from something different.
 \end{frame}
 %==============================
 …
         \begin{itemize}
                 \item Acquire for reading for normal scheduling operations.
                 \item Acquire for right when resizing the array and creating/deleting internal queues.
+                \item Acquire for writing when resizing the array and creating/deleting internal queues.
         \end{itemize}
 \end{frame}
 …
         Runtime system and scheduling are still open topics.
         \newline
+        \newline
         This work offers a novel runtime and scheduling package.
+        \newline
         \newline
 …
 %------------------------------
 \begin{frame}{Timeline}
+\begin{frame}{}
         \begin{center}
                 {\large Questions?}

doc/theses/thierry_delisle_PhD/comp_II/presentationstyle.sty

-              r4b30e8cc
+              rc28ea4e
 \setbeamertemplate{blocks}[rounded][shadow=false]
 \newcommand\xrowht[2][0]{\addstackgap[.5\dimexpr#2\relax]{\vphantom{#1}}}
+\setbeamertemplate{sections/subsections in toc}{\inserttocsectionnumber.~\inserttocsection}
 %==============================
 …
 \setbeamercolor{palette primary}{bg=colbg}
 \setbeamercolor{palette tertiary}{fg=red}
+\setbeamercolor{section in toc}{fg=white}
+\setbeamercolor{subsection in toc}{fg=gray}
 %==============================

doc/theses/thierry_delisle_PhD/thesis/Makefile

-              r4b30e8cc
+              rc28ea4e
         front \
         intro \
+        existing \
         runtime \
         core \
 …
         base \
         empty \
+        system \
+}
 …
 ## Define the documents that need to be made.
 all: thesis.pdf
 thesis.pdf: ${TEXTS} ${FIGURES} ${PICTURES} glossary.tex
+thesis.pdf: ${TEXTS} ${FIGURES} ${PICTURES} glossary.tex local.bib
 DOCUMENT = thesis.pdf

doc/theses/thierry_delisle_PhD/thesis/fig/system.fig

-              r4b30e8cc
+              rc28ea4e
 #FIG 3.2  Produced by xfig version 3.2.5c
+#FIG 3.2  Produced by xfig version 3.2.7b
 Landscape
 Center
 …
 3 0 1 -1 -1 0 0 20 0.000 1 0.0000 4500 3600 15 15 4500 3600 4515 3615
 -6
-3225 4125 4650 4425
-4350 4200 4650 4350
-3 0 1 -1 -1 0 0 20 0.000 1 0.0000 4425 4275 15 15 4425 4275 4440 4290
-3 0 1 -1 -1 0 0 20 0.000 1 0.0000 4500 4275 15 15 4500 4275 4515 4290
-3 0 1 -1 -1 0 0 20 0.000 1 0.0000 4575 4275 15 15 4575 4275 4590 4290
--6
-1 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3450 4275 225 150 3450 4275 3675 4425
-1 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4050 4275 225 150 4050 4275 4275 4425
--6
-6675 4125 7500 4425
-7200 4200 7500 4350
-3 0 1 -1 -1 0 0 20 0.000 1 0.0000 7275 4275 15 15 7275 4275 7290 4290
-3 0 1 -1 -1 0 0 20 0.000 1 0.0000 7350 4275 15 15 7350 4275 7365 4290
-3 0 1 -1 -1 0 0 20 0.000 1 0.0000 7425 4275 15 15 7425 4275 7440 4290
--6
-1 0 1 -1 -1 0 0 -1 0.000 1 0.0000 6900 4275 225 150 6900 4275 7125 4425
--6
 6675 3525 8025 3975
 1 0 1 -1 -1 0 0 -1 0.000 0 0 -1 1 0 2
 …
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3975 2850 150 150 3975 2850 4125 2850
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 7200 2775 150 150 7200 2775 7350 2775
 3 0 1 0 0 0 0 0 0.000 1 0.0000 2250 4830 30 30 2250 4830 2280 4860
+3 0 1 0 0 0 0 0 0.000 1 0.0000 2250 4830 30 30 2250 4830 2280 4830
 3 0 1 0 0 0 0 0 0.000 1 0.0000 7200 2775 30 30 7200 2775 7230 2805
 3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3525 3600 150 150 3525 3600 3675 3600
+3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 3875 4800 100 100 3875 4800 3975 4800
+1 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4650 4800 150 75 4650 4800 4800 4875
+3 0 1 -1 -1 0 0 -1 0.000 1 0.0000 4625 4838 100 100 4625 4838 4725 4838
 2 0 1 -1 -1 0 0 -1 0.000 0 0 0 0 0 5
 4200 2400 3750 1950 3750 1950 4200 2400 4200
 …
 1 1.00 45.00 90.00
 3750 7875 2325 7200 2325 7200 2550
+2 1 1 -1 -1 0 0 -1 3.000 0 0 0 0 0 5
+4950 6750 4950 6750 4725 6975 4725 6975 4950
 2 0 1 -1 -1 0 0 -1 0.000 0 0 0 0 0 5
 4950 5850 4725 5625 4725 5625 4950 5850 4950
+2 1 1 -1 -1 0 0 -1 3.000 0 0 0 0 0 5
+4950 6750 4950 6750 4725 6975 4725 6975 4950
+1 -1 0 0 0 10 0.0000 2 105 720 5550 4425 Processors\001
+1 -1 0 0 0 10 0.0000 2 120 1005 4200 3225 Blocked Tasks\001
+1 -1 0 0 0 10 0.0000 2 150 870 4200 3975 Ready Tasks\001
+1 -1 0 0 0 10 0.0000 2 135 1095 7350 1725 Other Cluster(s)\001
+1 -1 0 0 0 10 0.0000 2 105 840 4650 1725 User Cluster\001
+1 -1 0 0 0 10 0.0000 2 150 615 2175 3675 Manager\001
+1 -1 0 0 0 10 0.0000 2 105 990 2175 3525 Discrete-event\001
+1 -1 0 0 0 10 0.0000 2 135 795 2175 4350 preemption\001
+0 -1 0 0 0 10 0.0000 2 150 1290 2325 4875 generator/coroutine\001
+0 -1 0 0 0 10 0.0000 2 120 270 4050 4875 task\001
+0 -1 0 0 0 10 0.0000 2 105 450 7050 4875 cluster\001
+0 -1 0 0 0 10 0.0000 2 105 660 5925 4875 processor\001
+0 -1 0 0 0 10 0.0000 2 105 555 4875 4875 monitor\001
+1 -1 0 0 0 10 0.0000 2 135 900 5550 4425 Processors\001
+1 -1 0 0 0 10 0.0000 2 165 1170 4200 3975 Ready Threads\001
+1 -1 0 0 0 10 0.0000 2 165 1440 7350 1725 Other Cluster(s)\001
+1 -1 0 0 0 10 0.0000 2 135 1080 4650 1725 User Cluster\001
+1 -1 0 0 0 10 0.0000 2 165 630 2175 3675 Manager\001
+1 -1 0 0 0 10 0.0000 2 135 1260 2175 3525 Discrete-event\001
+1 -1 0 0 0 10 0.0000 2 150 900 2175 4350 preemption\001
+0 -1 0 0 0 10 0.0000 2 135 630 7050 4875 cluster\001
+1 -1 0 0 0 10 0.0000 2 135 1350 4200 3225 Blocked Threads\001
+0 -1 0 0 0 10 0.0000 2 135 540 4800 4875 thread\001
+0 -1 0 0 0 10 0.0000 2 120 810 5925 4875 processor\001
+0 -1 0 0 0 10 0.0000 2 165 1710 2325 4875 generator/coroutine\001

doc/theses/thierry_delisle_PhD/thesis/glossary.tex

-              r4b30e8cc
+              rc28ea4e
 \makeglossaries
+% ----------------------------------
+% Acronyms
+\newacronym{api}{API}{Application Programming Interface}
+\newacronym{fifo}{FIFO}{First-In, First-Out}
+\newacronym{io}{I/O}{Input and Output}
+\newacronym{numa}{NUMA}{Non-Uniform Memory Access}
+\newacronym{raii}{RAII}{Resource Acquisition Is Initialization}
+\newacronym{tls}{TLS}{Thread Local Storage}
+% ----------------------------------
+% Definitions
+\longnewglossaryentry{thrd}
+{name={thread}}
+{
+Threads created and managed inside user-space. Each thread has its own stack and its own thread of execution. User-level threads are invisible to the underlying operating system.
+\textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.}
+}
+\longnewglossaryentry{proc}
+{name={processor}}
+{
+}
+\longnewglossaryentry{rQ}
+{name={ready-queue}}
+{
+}
+\longnewglossaryentry{uthrding}
+{name={user-level threading}}
+{
+\textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.}
+}
+% ----------------------------------
 \longnewglossaryentry{hthrd}
 {name={hardware thread}}
+{
 Threads representing the underlying hardware directly.
+Threads representing the underlying hardware directly, \eg the CPU core, or hyper-thread if the hardware supports multiple threads of execution per core. The number of hardware threads is considered to be always fixed to a specific number determined by the hardware.
+\textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.}
+}
+\longnewglossaryentry{thrd}
+{name={threads}}
+{
+Threads created and managed inside user-space. Each thread has its own stack and its own thread of execution. User-level threads are invisible to the underlying operating system.
+\textit{Synonyms : User threads, Lightweight threads, Green threads, Virtual threads, Tasks.}
+\textit{Synonyms : }
+}
 …
+}
-\longnewglossaryentry{proc}
-{name={virtual processor}}
+{
+}
-\longnewglossaryentry{Q}
-{name={work-queue}}
+{
+}
 \longnewglossaryentry{at}
 …
+}
-\newacronym{tls}{TLS}{Thread Local Storage}
-\newacronym{api}{API}{Application Program Interface}
-\newacronym{raii}{RAII}{Resource Acquisition Is Initialization}
-\newacronym{numa}{NUMA}{Non-Uniform Memory Access}

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

-              r4b30e8cc
+              rc28ea4e
 \chapter{Scheduling Core}\label{core}
+This chapter addresses the need of scheduling on a somewhat ideal scenario
+Before discussing scheduling in general, where it is important to address systems that are changing states, this document discusses scheduling in a somewhat ideal scenerio, where the system has reached a steady state. For this purpose, a steady state is loosely defined as a state where there are always \glspl{thrd} ready to run and but the system has the ressources necessary to accomplish the work. In short, the system is neither overloaded or underloaded.
+\section{Existing Schedulers}
+\subsection{Feedback Scheduling}
+I believe it is important to discuss the steady state first because it is the easiest case to handle and, relatedly, the case in which the best performance is to be expected. As such, when the system is either overloaded or underloaded, a common approach is to try to adapt the system to the new load and return to the steady state. Flaws in the scheduling in the steady state tend therefore to be pervasive in all states.
+\subsection{Priority Scheduling}\label{priority}
+\section{Design Goals}
+As with most of the design decisions behind \CFA, the main goal is to match the expectation of the programmer, according to their probable mental model. To match these expectations, the design must offer the programmers sufficient guarantees so that, as long as the programmer respects the mental model, the system will also respect this model.
+\subsection{Work Stealing}
+For threading, a simple and common mental model is the ``Ideal multi-tasking CPU'' :
+\begin{displayquote}[Linux CFS\cit{https://www.kernel.org/doc/Documentation/scheduler/sched-design-CFS.txt}]
+        {[The]} ``Ideal multi-tasking CPU'' is a (non-existent  :-)) CPU that has 100\% physical power and which can run each task at precise equal speed, in parallel, each at [an equal fraction of the] speed.  For example: if there are 2 tasks running, then it runs each at 50\% physical power --- i.e., actually in parallel.
+\end{displayquote}
+Applied to threads, this model states that every ready \gls{thrd} immediately runs in parallel with all other ready \glspl{thrd}. While a strict implementation of this model is not feasible, programmers still have expectations about scheduling that come from this model.
+In general, the expectation at the center of this model is that ready \glspl{thrd} do not interfere with eachother but simply share the hardware. This makes it easier to reason about threading because ready \glspl{thrd} can be taken in isolation and the effect of the scheduler can be virtually ignored. This expectation of \gls{thrd} independence means the scheduler is expected to offer 2 guarantees:
+\begin{enumerate}
+        \item A fairness guarantee: a \gls{thrd} that is ready to run will not be prevented to do so by another thread.
+        \item A performance guarantee: a \gls{thrd} that wants to start or stop running will not be slowed down by other threads wanting to do the same.
+\end{enumerate}
+It is important to note that these guarantees are expected only up to a point. \Glspl{thrd} that are ready to run should not be prevented to do so, but they still need to share a limited amount of hardware. Therefore, the guarantee is considered respected if a \gls{thrd} gets access to a \emph{fair share} of the hardware, even if that share is very small.
+Similarly the performance guarantee, the lack of interferance between threads is only relevant op to a point. Ideally the cost of running and blocking would be constant regardless of contention, but the guarantee is considered satisfied if the cost is not \emph{too high} with or without contention. How much is an acceptable cost is obviously highly variable. For this document the performance experimentation will attempt to show that the cost of scheduling is not a major factor in application performance. This demonstration can be made by comparing application built in \CFA to applications built with other languages or other models. If the performance of an application built in \CFA is not meaningfully different than one built with a different runtime, then the scheduler has a negigeable impact on performance, \ie its impact can be ignored. Recall from a few paragraphs ago that the expectation of programmers is that the impact of the scheduler can be ignored. Therefore, if the cost of scheduling is not a significant portion of the runtime of several different application, I will consider the guarantee achieved.
+\todo{This paragraph should be moved later}
+% The next step is then to decide what is considered a \emph{fair share}, \ie what metric is used to measure fairness. Since \CFA is intended to allow numerous short lived threads, I decided to avoid total CPU time as the measure of fairness. Total CPU time inherently favors new \glspl{thrd} over older ones which isn't necessarily a good thing. Instead, fairness is measured in terms of opportunities to run. This metric is more appropriate for a mix of short and long lived \glspl{thrd}.
 \section{Design}
 While avoiding the pitfalls of Feedback Scheduling is fairly easy, scheduling does not innately require feedback, avoiding prioritization of \glspl{thrd} is more difficult because of implicitly priorities, see Subsection~\ref{priority}.
+While avoiding the pitfalls of Feedback Scheduling is fairly easy, scheduling does not innately require feedback, avoiding prioritization of \glspl{thrd} is more difficult because of implicitly priorities, see Subsection~\ref{priority}. A strictly \glsxtrshort{fifo} rea
 \subsection{Sharding}
 …
                 \input{base.pstex_t}
         \end{center}
+        \caption{Relaxed FIFO list at the base of the scheduler: an array of strictly FIFO lists.
+        The timestamp is in all nodes and cell arrays.}
+        \caption{Relaxed FIFO list}
         \label{fig:base}
+        List at the base of the scheduler: an array of strictly FIFO lists.
+        The timestamp is in all nodes and cell arrays.
 \end{figure}
 …
 Indeed, if the number of \glspl{thrd} does not far exceed the number of queues, it is probable that several of these 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 can lead to performance problems since picks that do not yield a \gls{thrd} are not useful and do not necessarily help make more informed guesses.
-Solutions to this problem can take many forms, but they ultimately all have to encode where the threads are in some form. My results show that the density and locality of this encoding is generally the dominating factor in these scheme.
-\paragraph{Dense Information}
 …
                 \input{empty.pstex_t}
         \end{center}
         \caption{``More empty'' state of the queue: the array contains many empty cells.}
+        \caption{``More empty'' Relaxed FIFO list}
         \label{fig:empty}
+        Emptier state of the queue: the array contains many empty cells, that is strictly FIFO lists containing no elements.
 \end{figure}
+This can lead to performance problems since picks that do not yield a \gls{thrd} are not useful and do not necessarily help make more informed guesses.
+Solutions to this problem can take many forms, but they ultimately all have to encode where the threads are in some form. My results show that the density and locality of this encoding is generally the dominating factor in these scheme.
+\paragraph{Dense Information}

doc/theses/thierry_delisle_PhD/thesis/text/front.tex

-              r4b30e8cc
+              rc28ea4e
 \phantomsection         % allows hyperref to link to the correct page
+% TODOs and missing citations
+% -----------------------------
 \listofcits
 \listoftodos
+\cleardoublepage
+\phantomsection         % allows hyperref to link to the correct page

doc/theses/thierry_delisle_PhD/thesis/text/intro.tex

-              r4b30e8cc
+              rc28ea4e
+\chapter{Introduction}
+\chapter*{Introduction}\label{intro}
+\todo{A proper intro}
+The C programming language\cit{C}
+The \CFA programming language\cite{cfa:frontpage,cfa:typesystem} which extends the C programming language to add modern safety and productiviy features while maintaining backwards compatibility. Among it's productiviy features, \CFA introduces support for threading\cit{CFA Concurrency}, to allow programmers to write modern concurrent and parallel programming.
+While previous work on the concurrent package of \CFA focused on features and interfaces, this thesis focuses on performance, introducing \glsxtrshort{api} changes only when required by performance considerations. More specifically, this thesis concentrates on scheduling and \glsxtrshort{io}. Prior to this work, the \CFA runtime used a strictly \glsxtrshort{fifo} \gls{rQ}.
+This work exclusively concentrates on Linux as it's operating system since the existing \CFA runtime and compiler does not already support other operating systems. Furthermore, as \CFA is yet to be released, supporting version of Linux older that the latest version is not a goal of this work.

doc/theses/thierry_delisle_PhD/thesis/text/io.tex

-              r4b30e8cc
+              rc28ea4e
+\chapter{I/O}
+\chapter{User Level \glsxtrshort{io}}
+As mentionned in Section~\ref{prev:io}, User-Level \glsxtrshort{io} requires multiplexing the \glsxtrshort{io} operations of many \glspl{thrd} onto fewer \glspl{proc} using asynchronous \glsxtrshort{io} operations. Various operating systems offer various forms of asynchronous operations and as mentioned in Chapter~\ref{intro}, this work is exclusively focuesd on Linux.
 \section{Existing options}
+Since \glsxtrshort{io} operations are generally handled by the
 \subsection{\texttt{epoll}, \texttt{poll} and \texttt{select}}
 …
 \subsection{Linux's AIO}
+\begin{displayquote}
+        AIO is a horrible ad-hoc design, with the main excuse being "other,
+        less gifted people, made that design, and we are implementing it for
+        compatibility because database people - who seldom have any shred of
+        taste - actually use it".
+        But AIO was always really really ugly.
+        \begin{flushright}
+                -- Linus Torvalds\cit{https://lwn.net/Articles/671657/}
+        \end{flushright}
+\end{displayquote}
+Interestingly, in this e-mail answer, Linus goes on to describe
+``a true \textit{asynchronous system call} interface''
+that does
+``[an] arbitrary system call X with arguments A, B, C, D asynchronously using a kernel thread''
+in
+``some kind of arbitrary \textit{queue up asynchronous system call} model''.
+This description is actually quite close to the interface of the interface described in the next section.
 \subsection{\texttt{io\_uring}}
+A very recent addition to Linux, \texttt{io\_uring}\cit{io\_uring} is a framework that aims to solve many of the problems listed with the above mentioned solutions.
+\subsection{Extra Kernel Threads}
+\subsection{Extra Kernel Threads}\label{io:morethreads}
+Finally, if the operating system does not offer any satisfying forms of asynchronous \glsxtrshort{io} operations, a solution is to fake it by creating a pool of \glspl{kthrd} and delegating operations to them in order to avoid blocking \glspl{proc}.
 \subsection{Discussion}

doc/theses/thierry_delisle_PhD/thesis/text/practice.tex

-              r4b30e8cc
+              rc28ea4e
 The scheduling algorithm discribed in Chapter~\ref{core} addresses scheduling in a stable state.
 However, it does not address problems that occur when the system changes state.
+Indeed the \CFA runtime, supports expanding and shrinking
+the number of KTHREAD\_place
+, both manually and, to some extent automatically.
+Indeed the \CFA runtime, supports expanding and shrinking the number of KTHREAD\_place \todo{add kthrd to glossary}, both manually and, to some extent automatically.
 This entails that the scheduling algorithm must support these transitions.

doc/theses/thierry_delisle_PhD/thesis/text/runtime.tex

-              r4b30e8cc
+              rc28ea4e
 \chapter{\CFA Runtime}
+This chapter offers an overview of the capabilities of the \CFA runtime prior to this work.
+\section{M:N Threading}
+Threading in \CFA offers is based on \Gls{uthrding}, where \glspl{thrd} are the representation of a unit of work. As such, \CFA programmers should expect these units to be fairly inexpensive, that is: programmers should be able to create a large number of \glspl{thrd} and switch between \glspl{thrd} liberally without many concerns for performance.
+\section{M:N Threading}\label{prev:model}
+C traditionnally uses a 1:1 threading model. This model uses \glspl{kthrd} to achive parallelism and concurrency. In this model, every thread of computation maps to an object in the kernel. The kernel then has the responsibility of managing these threads, \eg creating, scheduling, blocking. This also entails that the kernel has a perfect view of every thread executing in the system\footnote{This is not completly true due to primitives like \texttt{futex}es, which have a significant portion of their logic in user space.}.
+By contrast \CFA uses an M:N threading models, where concurrency is achieved using many user-level threads mapped onto fewer \glspl{kthrd}. The user-level threads have the same semantic meaning as a \glspl{kthrd} in the 1:1 model, they represent an independant thread of execution with it's on stack. The difference is that user-level threads do not have a corresponding object in the kernel, they are handled by the runtime in user space and scheduled onto \glspl{kthrd}, referred to as \glspl{proc} in this document. \Glspl{proc} run a \gls{thrd} until it context switches out, it then choses a different \gls{thrd} to run.
 \section{Clusters}
+\begin{figure}
+        \begin{center}
+                \input{system.pstex_t}
+        \end{center}
+        \caption{Overview of the \CFA runtime}
+        \label{fig:system}
+        \Glspl{thrd} are scheduled inside a particular cluster, where it only runs on the \glspl{proc} which belong to the cluster. The discrete-event manager, which handles preemption and timeout, is a \gls{kthrd} which lives outside any cluster and does not run \glspl{thrd}.
+\end{figure}
+\CFA allows the option to group user-level threading, in the form of clusters. Both \glspl{thrd} and \glspl{proc} belong to a specific cluster. \Glspl{thrd} will only be scheduled onto \glspl{proc} in the same cluster and scheduling is done independantly of other clusters. Figure~\ref{fig:system} shows an overview if this system. This allows programmers to control more tightly parallelism. It also opens the door to handling effects like NUMA, by pining clusters to specific NUMA node\footnote{This is not currently implemented in \CFA, but the only hurdle left is creating a generic interface for cpu masks.}.
+\section{Scheduling}
+The \CFA runtime was previously using a strictly \glsxtrshort{fifo} ready queue with a single lock. This setup offers perfect fairness in terms of opportunities to run/ However, it offers poor scalability, since the performance of the ready queue can never be improved by adding more \glspl{hthrd}, but the contention can cause significant performance degradation.
+\section{\glsxtrshort{io}}\label{prev:io}
+Prior to this work, the \CFA runtime did not add any particular support for \glsxtrshort{io} operations. \CFA being built on C, this means that, while all the operations available in C are available in \CFA, \glsxtrshort{io} operations are designed for the POSIX threading model\cit{pthreads}. Using these operations in a M:N threading model, when they are built for 1:1 threading, means that operations block \glspl{proc} instead of \glspl{thrd}. While this can work in certain cases, it limits the number of concurrent operations to the number of \glspl{proc} rather than \glspl{thrd}. This also means that deadlocks can occur because all \glspl{proc} are blocked even if at least one \gls{thrd} is ready to run. A simple example of this type of deadlock would be as follows:
+Given a simple network program with 2 \glspl{thrd} and a single \gls{proc}, one \gls{thrd} sends network requests to a server and the other \gls{thrd} waits for response from the server. If the second \gls{thrd} races ahead, it may wait for responses to requests that have not been sent yet. In theory, this should not be a problem, even if the second \gls{thrd} waits, the first \gls{thrd} is still ready to run and should just be able to get CPU time and send the request. In practice with M:N threading, while the first \gls{thrd} is ready, the lone \gls{proc} in this example will \emph{not} try to run the first \gls{thrd} if it is blocked in the \glsxtrshort{io} operation of the second \gls{thrd}. If this happen, the system is effectively deadlocked\footnote{In this example, the deadlocked could be resolved if the server sends unprompted messages to the client. However, this solution is not general and may not be appropriate even in this simple case.}.
+One of the objective of this work, is to introduce \emph{User-Level \glsxtrshort{io}} which, as a parallel to \glslink{uthrding}{User-Level \emph{Threading}}, blocks \glspl{thrd} rather than \glspl{proc} when doing \glsxtrshort{io} operations. This entails multiplexing the \glsxtrshort{io} operations of many \glspl{thrd} onto fewer \glspl{proc}. This multiplexing requires that a single \gls{proc} be able to execute multiple operations in parallel. This cannot be done with operations that block \glspl{proc}, \ie \glspl{kthrd}, since the first operation would prevent starting new operations for its duration. Executing operations in parallel requires \emph{asynchronous} \glsxtrshort{io}, sometimes referred to as \emph{non-blocking}, since the \gls{kthrd} is not blocked.
 \section{Interoperating with \texttt{C}}
+While \glsxtrshort{io} operations are the classical example of operations that block \glspl{kthrd}, the challenges mentioned in the previous section do not require \glsxtrshort{io} to be involved. These challenges are a product of blocking system calls rather than \glsxtrshort{io}. C offers no tools to identify whether or not a librairy function will lead to a blocking system call. This fact means interoperatability with C becomes a challenge in a M:N threading model.
+Languages like Go and Java, which have strict interoperatability with C\cit{JNI, GoLang with C}, can control operations in C by ``sandboxing'' them. They can, for example, delegate C operations to \glspl{kthrd} that are not \glspl{proc}. Sandboxing may help towards guaranteeing that the deadlocks mentioned in the previous section do not occur.
+As mentioned in Section~\cit{\CFA intro}, \CFA is binary compatible with C and, as such, trivially supports calls to and from C librairies. Furthermore, interoperatability can happen within a single library, through inline code or simply C and \CFA translation units archived together. The fine-grained interoperatability between C and \CFA has two consequences:
+\begin{enumerate}
+        \item Precisely identifying C calls that could block is difficult.
+        \item Introducing code where interoperatability occurs could have a significant impact on general performance.
+\end{enumerate}
+Because of these consequences, this work does not attempt to ``sandbox'' calls to C. It is possible that conflicting calls to C could lead to deadlocks on \CFA's M:N threading model where they would not in the traditionnal 1:1 threading model. However, I judge that solving this problem in general, in a way that is composable and flexible, is too complex in itself and would add too much work to this thesis. Therefore it is outside the scope of this thesis.

doc/theses/thierry_delisle_PhD/thesis/thesis.tex

-              r4b30e8cc
+              rc28ea4e
 % installation instructions there.
+\usepackage{csquotes}
+\usepackage{indentfirst} % as any self-respecting frenchman would
 % Setting up the page margins...
 % uWaterloo thesis requirements specify a minimum of 1 inch (72pt) margin at the
 …
 % separate documents, they would each start with the \chapter command, i.e,
 % do not contain \documentclass or \begin{document} and \end{document} commands.
+\part{Introduction}
 \input{text/intro.tex}
+\input{text/existing.tex}
 \input{text/runtime.tex}
+\part{Design}
 \input{text/core.tex}
 \input{text/practice.tex}
 \input{text/io.tex}
+\part{Evaluation}
+\chapter{Theoretical and Existance Proofs}
+\chapter{Micro-Benchmarks}
+\chapter{Larger-Scale applications}
+\part{Conclusion \& Annexes}
 %----------------------------------------------------------------------
 …
 \addcontentsline{toc}{chapter}{\textbf{References}}
 \bibliography{uw-ethesis}
+\bibliography{local}
 % Tip 5: You can create multiple .bib files to organize your references.
 % Just list them all in the \bibliogaphy command, separated by commas (no spaces).
 % The following statement causes the specified references to be added to the bibliography% even if they were not
 % cited in the text. The asterisk is a wildcard that causes all entries in the bibliographic database to be included (optional).
 \nocite{*}
+% % The following statement causes the specified references to be added to the bibliography% even if they were not
+% % cited in the text. The asterisk is a wildcard that causes all entries in the bibliographic database to be included (optional).
+% \nocite{*}
 % The \appendix statement indicates the beginning of the appendices.

libcfa/prelude/builtins.c

-              r4b30e8cc
+              rc28ea4e
 // Author           : Peter A. Buhr
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Oct  9 18:26:19 2020
 // Update Count     : 110
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct 27 14:42:00 2020
+// Update Count     : 111
 //
+#define __cforall_builtins__
 // type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct members in user-defined functions

libcfa/src/concurrency/clib/cfathread.cfa

r4b30e8cc	rc28ea4e
59	59	void cfathread_setproccnt( int ncnt ) {
60	60	assert( ncnt >= 1 );
61		adelete(~~proc_cnt, procs~~);
	61	adelete( procs );
62	62
63	63	proc_cnt = ncnt - 1;

libcfa/src/concurrency/coroutine.cfa

-              r4b30e8cc
+              rc28ea4e
 // Created On       : Mon Nov 28 12:27:26 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue May 26 22:06:09 2020
 // Update Count     : 21
+// Last Modified On : Fri Oct 23 23:05:24 2020
+// Update Count     : 22
 //
 …
 #include <unistd.h>
 #include <sys/mman.h>                                                                   // mprotect
-extern "C" {
-// use this define to make unwind.h play nice, definitely a hack
-#define HIDE_EXPORTS
 #include <unwind.h>
-#undef HIDE_EXPORTS
+}
 #include "kernel_private.hfa"
+#include "exception.hfa"
 #define __CFA_INVOKE_PRIVATE__
 …
 FORALL_DATA_INSTANCE(CoroutineCancelled, (dtype coroutine_t), (coroutine_t))
-struct __cfaehm_node {
-        struct _Unwind_Exception unwind_exception;
-        struct __cfaehm_node * next;
-        int handler_index;
-};
 forall(dtype T)
 void mark_exception(CoroutineCancelled(T) *) {}
 …
 forall(dtype T)
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
+        dst->virtual_table = src->virtual_table;
         dst->the_coroutine = src->the_coroutine;
         dst->the_exception = src->the_exception;
 …
         verify( desc->cancellation );
         desc->state = Cancelled;
         exception_t * except = (exception_t *)(1 + (__cfaehm_node *)desc->cancellation);
+        exception_t * except = __cfaehm_cancellation_exception( desc->cancellation );
         // TODO: Remove explitate vtable set once trac#186 is fixed.
 …
 // minimum feasible stack size in bytes
+#define MinStackSize 1000
+static const size_t MinStackSize = 1000;
 extern size_t __page_size;                              // architecture pagesize HACK, should go in proper runtime singleton
 …
                 size = libFloor(create_size - stack_data_size - diff, libAlign());
         } // if
         assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %d bytes for a stack.", size, MinStackSize );
+        assertf( size >= MinStackSize, "Stack size %zd provides less than minimum of %zd bytes for a stack.", size, MinStackSize );
         this->storage = (__stack_t *)((intptr_t)storage + size);

libcfa/src/concurrency/exception.cfa

-              r4b30e8cc
+              rc28ea4e
 // Created On       : Mon Aug 17 10:41:00 2020
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Aug 25 14:41:00 2020
 // Update Count     : 0
+// Last Modified On : Wed Oct 28 14:34:00 2020
+// Update Count     : 1
 //
+extern "C" {
+// use this define to make unwind.h play nice, definitely a hack
+#define HIDE_EXPORTS
+#include <unwind.h>
+#undef HIDE_EXPORTS
+}
+#define __cforall_thread__
-#include "invoke.h"
 #include "exception.hfa"
 #include "coroutine.hfa"
 extern struct $thread * mainThread;
+extern "C" {
+extern void __cfactx_thrd_leave();
+}
 // Common pattern for all the stop functions, wait until the end then act.
 …
 STOP_AT_END_FUNCTION(thread_cancelstop,
         // TODO: Instead pass information to the joiner.
         abort();
+        __cfactx_thrd_leave();
+        __cabi_abort( "Resumed cancelled thread" );
+)
 …
                 stop_param = (void *)0x22;
         } else {
+                this_thread->self_cor.cancellation = unwind_exception;
                 stop_func = thread_cancelstop;
                 stop_param = this_thread;

libcfa/src/concurrency/exception.hfa

-              r4b30e8cc
+              rc28ea4e
 #pragma once
+// This is an internal bridge between the two modes and must be C compatable.
+#include <unwind.h>
 #include "bits/defs.hfa"
 #include "invoke.h"
+#include "exception.h"
 #ifdef __cforall
 extern "C" {
-#define HIDE_EXPORTS
 #endif
-#include "unwind.h"
 struct exception_context_t * this_exception_context(void) OPTIONAL_THREAD;
 …
 #ifdef __cforall
-#undef HIDE_EXPORTS
+}
 #endif

libcfa/src/concurrency/invoke.h

-              r4b30e8cc
+              rc28ea4e
                 // current execution status for coroutine
+                // Possible values are:
+                //    - TICKET_BLOCKED (-1) thread is blocked
+                //    - TICKET_RUNNING ( 0) thread is running
+                //    - TICKET_UNBLOCK ( 1) thread should ignore next block
                 volatile int ticket;
                 enum __Coroutine_State state:8;

libcfa/src/concurrency/io/call.cfa.in

-              r4b30e8cc
+              rc28ea4e
         #include "kernel/fwd.hfa"
+        #if defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_IO_DRAIN) && defined(CFA_HAVE_IOSQE_ASYNC)
+                #define REGULAR_FLAGS (IOSQE_FIXED_FILE | IOSQE_IO_DRAIN | IOSQE_ASYNC)
+        #elif defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_ASYNC)
+                #define REGULAR_FLAGS (IOSQE_FIXED_FILE | IOSQE_ASYNC)
+        #elif defined(CFA_HAVE_IOSQE_FIXED_FILE) && defined(CFA_HAVE_IOSQE_IO_DRAIN)
+                #define REGULAR_FLAGS (IOSQE_FIXED_FILE | IOSQE_IO_DRAIN)
+        #elif defined(CFA_HAVE_IOSQE_IO_DRAIN) && defined(CFA_HAVE_IOSQE_ASYNC)
+                #define REGULAR_FLAGS (IOSQE_IO_DRAIN | IOSQE_ASYNC)
+        #elif defined(CFA_HAVE_IOSQE_FIXED_FILE)
+                #define REGULAR_FLAGS (IOSQE_FIXED_FILE)
+        #elif defined(CFA_HAVE_IOSQE_IO_DRAIN)
+                #define REGULAR_FLAGS (IOSQE_IO_DRAIN)
+        #elif defined(CFA_HAVE_IOSQE_ASYNC)
+                #define REGULAR_FLAGS (IOSQE_ASYNC)
+        #else
+                #define REGULAR_FLAGS (0)
+        #endif
+        #if defined(CFA_HAVE_IOSQE_IO_LINK) && defined(CFA_HAVE_IOSQE_IO_HARDLINK)
+                #define LINK_FLAGS (IOSQE_IO_LINK | IOSQE_IO_HARDLINK)
+        #elif defined(CFA_HAVE_IOSQE_IO_LINK)
+                #define LINK_FLAGS (IOSQE_IO_LINK)
+        #elif defined(CFA_HAVE_IOSQE_IO_HARDLINK)
+                #define LINK_FLAGS (IOSQE_IO_HARDLINK)
+        #else
+                #define LINK_FLAGS (0)
+        #endif
+        #if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
+                #define SPLICE_FLAGS (SPLICE_F_FD_IN_FIXED)
+        #else
+                #define SPLICE_FLAGS (0)
+        #endif
+        static const __u8 REGULAR_FLAGS = 0
+                #if defined(CFA_HAVE_IOSQE_FIXED_FILE)
+                        | IOSQE_FIXED_FILE
+                #endif
+                #if defined(CFA_HAVE_IOSQE_IO_DRAIN)
+                        | IOSQE_IO_DRAIN
+                #endif
+                #if defined(CFA_HAVE_IOSQE_ASYNC)
+                        | IOSQE_ASYNC
+                #endif
+        ;
+        static const __u32 LINK_FLAGS = 0
+                #if defined(CFA_HAVE_IOSQE_IO_LINK)
+                        | IOSQE_IO_LINK
+                #endif
+                #if defined(CFA_HAVE_IOSQE_IO_HARDLINK)
+                        | IOSQE_IO_HARDLINK
+                #endif
+        ;
+        static const __u32 SPLICE_FLAGS = 0
+                #if defined(CFA_HAVE_SPLICE_F_FD_IN_FIXED)
+                        | SPLICE_F_FD_IN_FIXED
+                #endif
+        ;
         extern [* struct io_uring_sqe, __u32] __submit_alloc( struct __io_data & ring, __u64 data );

libcfa/src/concurrency/io/setup.cfa

-              r4b30e8cc
+              rc28ea4e
                 id.full_proc = false;
                 id.id = doregister(&id);
+                kernelTLS.this_proc_id = &id;
                 __cfaabi_dbg_print_safe( "Kernel : IO poller thread starting\n" );
 …
                                         kernelTLS.this_stats = io_ctx->self.curr_cluster->stats;
                                 #endif
                                 __post( io_ctx->sem, &id );
+                                post( io_ctx->sem );
+                        }
+                }
 …
                         if( thrd.state == Ready || thrd.preempted != __NO_PREEMPTION ) {
                                 ready_schedule_lock( (struct __processor_id_t *)active_processor() );
+                                ready_schedule_lock();
                                         // This is the tricky case
 …
                                         // Fixup the thread state
                                         thrd.state = Blocked;
                                         thrd.ticket = 0;
+                                        thrd.ticket = TICKET_BLOCKED;
                                         thrd.preempted = __NO_PREEMPTION;
                                 ready_schedule_unlock( (struct __processor_id_t *)active_processor() );
+                                ready_schedule_unlock();
                                 // Pretend like the thread was blocked all along
 …
+                        }
                 } else {
                         unpark( &thrd );
+                        post( this.thrd.sem );
+                }

libcfa/src/concurrency/kernel.cfa

-              r4b30e8cc
+              rc28ea4e
 static $thread * __next_thread_slow(cluster * this);
 static void __run_thread(processor * this, $thread * dst);
 static void __wake_one(struct __processor_id_t * id, cluster * cltr);
+static void __wake_one(cluster * cltr);
 static void push  (__cluster_idles & idles, processor & proc);
 …
                 /* paranoid */ verify( kernelTLS.this_thread == thrd_dst );
                 /* paranoid */ verify( thrd_dst->context.SP );
+                /* paranoid */ verify( thrd_dst->state != Halted );
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
                 /* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) > ((uintptr_t)__get_stack(thrd_dst->curr_cor)->limit) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too large.\n", thrd_dst ); // add escape condition if we are setting up the processor
 …
                 if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
                         // The thread was preempted, reschedule it and reset the flag
                         __schedule_thread( (__processor_id_t*)this, thrd_dst );
+                        __schedule_thread( thrd_dst );
                         break RUNNING;
+                }
 …
                 if(unlikely(thrd_dst->state == Halted)) {
                         // The thread has halted, it should never be scheduled/run again
+                        // We may need to wake someone up here since
+                        unpark( this->destroyer );
+                        this->destroyer = 0p;
+                        // finish the thread
+                        __thread_finish( thrd_dst );
                         break RUNNING;
+                }
 …
                 int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
                 switch(old_ticket) {
                         case 1:
+                        case TICKET_RUNNING:
                                 // This is case 1, the regular case, nothing more is needed
                                 break RUNNING;
                         case 2:
+                        case TICKET_UNBLOCK:
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
                                 // In this case, just run it again.
 …
 // Scheduler routines
 // KERNEL ONLY
 void __schedule_thread( struct __processor_id_t * id, $thread * thrd ) {
+void __schedule_thread( $thread * thrd ) {
         /* paranoid */ verify( thrd );
         /* paranoid */ verify( thrd->state != Halted );
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
         /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
         /* paranoid */  if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
 …
         if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
         ready_schedule_lock  ( id );
+        ready_schedule_lock();
                 push( thrd->curr_cluster, thrd );
                 __wake_one(id, thrd->curr_cluster);
         ready_schedule_unlock( id );
+                __wake_one(thrd->curr_cluster);
+        ready_schedule_unlock();
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 …
 // KERNEL ONLY
 static inline $thread * __next_thread(cluster * this) with( *this ) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_lock();
                 $thread * thrd = pop( this );
+        ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_unlock();
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
         return thrd;
+}
 …
 // KERNEL ONLY
 static inline $thread * __next_thread_slow(cluster * this) with( *this ) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_lock();
                 $thread * thrd = pop_slow( this );
+        ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_unlock();
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
         return thrd;
+}
+// KERNEL ONLY unpark with out disabling interrupts
+void __unpark(  struct __processor_id_t * id, $thread * thrd ) {
+void unpark( $thread * thrd ) {
+        if( !thrd ) return;
+        /* paranoid */ verify( kernelTLS.this_proc_id );
+        bool full = kernelTLS.this_proc_id->full_proc;
+        if(full) disable_interrupts();
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
         switch(old_ticket) {
                 case 1:
+                case TICKET_RUNNING:
                         // Wake won the race, the thread will reschedule/rerun itself
                         break;
                 case 0:
+                case TICKET_BLOCKED:
                         /* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
                         /* paranoid */ verify( thrd->state == Blocked );
                         // Wake lost the race,
                         __schedule_thread( id, thrd );
+                        __schedule_thread( thrd );
                         break;
                 default:
                         // This makes no sense, something is wrong abort
+                        abort();
+        }
+}
+void unpark( $thread * thrd ) {
+        if( !thrd ) return;
+        disable_interrupts();
+        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd );
+        enable_interrupts( __cfaabi_dbg_ctx );
+                        abort("Thread %p (%s) has mismatch park/unpark\n", thrd, thrd->self_cor.name);
+        }
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        if(full) enable_interrupts( __cfaabi_dbg_ctx );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
+}
 …
+}
+// KERNEL ONLY
+void __leave_thread() {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        abort();
+extern "C" {
+        // Leave the thread monitor
+        // last routine called by a thread.
+        // Should never return
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
+                // Lock the monitor now
+                lock( this->lock __cfaabi_dbg_ctx2 );
+                disable_interrupts();
+                thrd->state = Halted;
+                if( TICKET_RUNNING != thrd->ticket ) { abort( "Thread terminated with pending unpark" ); }
+                if( thrd != this->owner || this->recursion != 1) { abort( "Thread internal monitor has unbalanced recursion" ); }
+                // Leave the thread
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                returnToKernel();
+                abort();
+                // Control flow should never reach here!
+        }
+}
 …
 //=============================================================================================
 // Wake a thread from the front if there are any
 static void __wake_one(struct __processor_id_t * id, cluster * this) {
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         /* paranoid */ verify( ready_schedule_islocked( id ) );
+static void __wake_one(cluster * this) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ready_schedule_islocked() );
         // Check if there is a sleeping processor
 …
         #endif
         /* paranoid */ verify( ready_schedule_islocked( id ) );
+        /* paranoid */ verify( ready_schedule_islocked() );
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 …
                 this.print_halts = true;
+        }
+        void print_stats_now( cluster & this, int flags ) {
+                __print_stats( this.stats, this.print_stats, true, this.name, (void*)&this );
+        }
 #endif
 // Local Variables: //

libcfa/src/concurrency/kernel.hfa

-              r4b30e8cc
+              rc28ea4e
         // Handle to pthreads
         pthread_t kernel_thread;
-        // RunThread data
-        // Action to do after a thread is ran
-        $thread * destroyer;
         // Preemption data

libcfa/src/concurrency/kernel/fwd.hfa

-              r4b30e8cc
+              rc28ea4e
         extern "Cforall" {
                 extern __attribute__((aligned(128))) thread_local struct KernelThreadData {
+                        struct $thread    * volatile this_thread;
+                        struct processor  * volatile this_processor;
+                        struct __stats_t  * volatile this_stats;
+                        struct $thread          * volatile this_thread;
+                        struct processor        * volatile this_processor;
+                        struct __processor_id_t * volatile this_proc_id;
+                        struct __stats_t        * volatile this_stats;
                         struct {

libcfa/src/concurrency/kernel/startup.cfa

-              r4b30e8cc
+              rc28ea4e
         NULL,
         NULL,
+        NULL,
         { 1, false, false },
 };
 …
         //initialize the global state variables
         kernelTLS.this_processor = mainProcessor;
+        kernelTLS.this_proc_id   = (__processor_id_t*)mainProcessor;
         kernelTLS.this_thread    = mainThread;
 …
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
         __schedule_thread((__processor_id_t *)mainProcessor, mainThread);
+        __schedule_thread(mainThread);
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
 …
         processor * proc = (processor *) arg;
         kernelTLS.this_processor = proc;
+        kernelTLS.this_proc_id   = (__processor_id_t*)proc;
         kernelTLS.this_thread    = 0p;
         kernelTLS.preemption_state.[enabled, disable_count] = [false, 1];
 …
 static void ?{}( $thread & this, current_stack_info_t * info) with( this ) {
         ticket = 1;
+        ticket = TICKET_RUNNING;
         state = Start;
         self_cor{ info };
 …
         this.cltr = &_cltr;
         full_proc = true;
-        destroyer = 0p;
         do_terminate = false;
         preemption_alarm = 0p;

libcfa/src/concurrency/kernel_private.hfa

-              r4b30e8cc
+              rc28ea4e
+}
 void __schedule_thread( struct __processor_id_t *, $thread * )
+void __schedule_thread( $thread * )
 #if defined(NDEBUG) || (!defined(__CFA_DEBUG__) && !defined(__CFA_VERIFY__))
         __attribute__((nonnull (2)))
+        __attribute__((nonnull (1)))
 #endif
+;
 //Block current thread and release/wake-up the following resources
 void __leave_thread() __attribute__((noreturn));
+//release/wake-up the following resources
+void __thread_finish( $thread * thrd );
 //-----------------------------------------------------------------------------
 …
+)
+// KERNEL ONLY unpark with out disabling interrupts
+void __unpark( struct __processor_id_t *, $thread * thrd );
+static inline bool __post(single_sem & this, struct __processor_id_t * id) {
+        for() {
+                struct $thread * expected = this.ptr;
+                if(expected == 1p) return false;
+                if(expected == 0p) {
+                        if(__atomic_compare_exchange_n(&this.ptr, &expected, 1p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                return false;
+                        }
+                }
+                else {
+                        if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                __unpark( id, expected );
+                                return true;
+                        }
+                }
+        }
+}
+#define TICKET_BLOCKED (-1) // thread is blocked
+#define TICKET_RUNNING ( 0) // thread is running
+#define TICKET_UNBLOCK ( 1) // thread should ignore next block
 //-----------------------------------------------------------------------------
 …
 // Reader side : acquire when using the ready queue to schedule but not
 //  creating/destroying queues
+static inline void ready_schedule_lock( struct __processor_id_t * proc) with(*__scheduler_lock) {
+        unsigned iproc = proc->id;
+        /*paranoid*/ verify(data[iproc].handle == proc);
+static inline void ready_schedule_lock(void) with(*__scheduler_lock) {
+        /*paranoid*/ verify( kernelTLS.this_proc_id );
+        unsigned iproc = kernelTLS.this_proc_id->id;
+        /*paranoid*/ verify(data[iproc].handle == kernelTLS.this_proc_id);
         /*paranoid*/ verify(iproc < ready);
 …
+}
+static inline void ready_schedule_unlock( struct __processor_id_t * proc) with(*__scheduler_lock) {
+        unsigned iproc = proc->id;
+        /*paranoid*/ verify(data[iproc].handle == proc);
+static inline void ready_schedule_unlock(void) with(*__scheduler_lock) {
+        /*paranoid*/ verify( kernelTLS.this_proc_id );
+        unsigned iproc = kernelTLS.this_proc_id->id;
+        /*paranoid*/ verify(data[iproc].handle == kernelTLS.this_proc_id);
         /*paranoid*/ verify(iproc < ready);
         /*paranoid*/ verify(data[iproc].lock);
 …
 #ifdef __CFA_WITH_VERIFY__
+        static inline bool ready_schedule_islocked( struct __processor_id_t * proc) {
+        static inline bool ready_schedule_islocked(void) {
+                /*paranoid*/ verify( kernelTLS.this_proc_id );
+                __processor_id_t * proc = kernelTLS.this_proc_id;
                 return __scheduler_lock->data[proc->id].owned;
+        }

libcfa/src/concurrency/monitor.cfa

-              r4b30e8cc
+              rc28ea4e
+}
+extern "C" {
+        // Leave the thread monitor
+        // last routine called by a thread.
+        // Should never return
+        void __cfactx_thrd_leave() {
+                $thread * thrd = TL_GET( this_thread );
+                $monitor * this = &thrd->self_mon;
+                // Lock the monitor now
+                lock( this->lock __cfaabi_dbg_ctx2 );
+                disable_interrupts();
+                thrd->state = Halted;
+                /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+                // Leaving a recursion level, decrement the counter
+                this->recursion -= 1;
+                // If we haven't left the last level of recursion
+                // it must mean there is an error
+                if( this->recursion != 0) { abort( "Thread internal monitor has unbalanced recursion" ); }
+                // Fetch the next thread, can be null
+                $thread * new_owner = next_thread( this );
+                // Release the monitor lock
+                unlock( this->lock );
+                // Unpark the next owner if needed
+                /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+                /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+                /* paranoid */ verify( ! kernelTLS.this_processor->destroyer );
+                /* paranoid */ verify( thrd->state == Halted );
+                kernelTLS.this_processor->destroyer = new_owner;
+                // Leave the thread
+                __leave_thread();
+                // Control flow should never reach here!
+        }
+}
+// Join a thread
+forall( dtype T | is_thread(T) )
+T & join( T & this ) {
+        $monitor *    m = get_monitor(this);
+        void (*dtor)(T& mutex this) = ^?{};
+        monitor_dtor_guard_t __guard = { &m, (fptr_t)dtor, true };
+        {
+                return this;
+        }
+void __thread_finish( $thread * thrd ) {
+        $monitor * this = &thrd->self_mon;
+        // Lock the monitor now
+        /* paranoid */ verify( this->lock.lock );
+        /* paranoid */ verifyf( thrd == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", thrd, this->owner, this->recursion, this );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( thrd->state == Halted );
+        /* paranoid */ verify( this->recursion == 1 );
+        // Leaving a recursion level, decrement the counter
+        this->recursion -= 1;
+        this->owner = 0p;
+        // Fetch the next thread, can be null
+        $thread * new_owner = next_thread( this );
+        // Release the monitor lock
+        unlock( this->lock );
+        // Unpark the next owner if needed
+        /* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( thrd->state == Halted );
+        unpark( new_owner );
+}

libcfa/src/concurrency/preemption.cfa

-              r4b30e8cc
+              rc28ea4e
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
 static void timeout( struct __processor_id_t * id, $thread * this );
+static void timeout( $thread * this );
 // FwdDeclarations : Signal handlers
 …
 // Tick one frame of the Discrete Event Simulation for alarms
 static void tick_preemption( struct __processor_id_t * id ) {
+static void tick_preemption(void) {
         alarm_node_t * node = 0p;                                                       // Used in the while loop but cannot be declared in the while condition
         alarm_list_t * alarms = &event_kernel->alarms;          // Local copy for ease of reading
 …
+                }
                 else if( node->type == User ) {
                         timeout( id, node->thrd );
+                        timeout( node->thrd );
+                }
                 else {
                         bool unpark_thd = node->callback(*node);
                         if (unpark_thd) timeout( id, node->thrd );
+                        if (unpark_thd) timeout( node->thrd );
+                }
 …
 // reserved for future use
 static void timeout( struct __processor_id_t * id, $thread * this ) {
+static void timeout( $thread * this ) {
         #if !defined( __CFA_NO_STATISTICS__ )
                 kernelTLS.this_stats = this->curr_cluster->stats;
         #endif
         __unpark( id, this );
+        unpark( this );
+}
 …
         id.full_proc = false;
         id.id = doregister(&id);
+        kernelTLS.this_proc_id = &id;
         // Block sigalrms to control when they arrive
 …
                         // __cfaabi_dbg_print_safe( "Kernel : Preemption thread tick\n" );
                         lock( event_kernel->lock __cfaabi_dbg_ctx2 );
                         tick_preemption( &id );
+                        tick_preemption();
                         unlock( event_kernel->lock );
                         break;

libcfa/src/concurrency/snzi.hfa

r4b30e8cc	rc28ea4e
36	36	static inline void depart( __snzi_node_t & );
37	37
38		#define __snzi_half -1
	38	static const int __snzi_half = -1;
39	39
40	40	//--------------------------------------------------

libcfa/src/concurrency/thread.cfa

-              r4b30e8cc
+              rc28ea4e
 #include "kernel_private.hfa"
+#include "exception.hfa"
 #define __CFA_INVOKE_PRIVATE__
 …
         context{ 0p, 0p };
         self_cor{ name, storage, storageSize };
         ticket = 1;
+        ticket = TICKET_RUNNING;
         state = Start;
         preempted = __NO_PREEMPTION;
 …
+}
+FORALL_DATA_INSTANCE(ThreadCancelled, (dtype thread_t), (thread_t))
+forall(dtype T)
+void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src) {
+        dst->virtual_table = src->virtual_table;
+        dst->the_thread = src->the_thread;
+        dst->the_exception = src->the_exception;
+}
+forall(dtype T)
+const char * msg(ThreadCancelled(T) *) {
+        return "ThreadCancelled";
+}
+forall(dtype T)
+static void default_thread_cancel_handler(ThreadCancelled(T) & ) {
+        abort( "Unhandled thread cancellation.\n" );
+}
+forall(dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)))
+void ?{}( thread_dtor_guard_t & this,
+                T & thrd, void(*defaultResumptionHandler)(ThreadCancelled(T) &)) {
+        $monitor * m = get_monitor(thrd);
+        void (*dtor)(T& mutex this) = ^?{};
+        bool join = defaultResumptionHandler != (void(*)(ThreadCancelled(T)&))0;
+        (this.mg){&m, (void(*)())dtor, join};
+        // After the guard set-up and any wait, check for cancellation.
+        $thread * desc = get_thread(thrd);
+        struct _Unwind_Exception * cancellation = desc->self_cor.cancellation;
+        if ( likely( 0p == cancellation ) ) {
+                return;
+        } else if ( Cancelled == desc->state ) {
+                return;
+        }
+        desc->state = Cancelled;
+        if (!join) {
+                defaultResumptionHandler = default_thread_cancel_handler;
+        }
+        ThreadCancelled(T) except;
+        // TODO: Remove explitate vtable set once trac#186 is fixed.
+        except.virtual_table = &get_exception_vtable(&except);
+        except.the_thread = &thrd;
+        except.the_exception = __cfaehm_cancellation_exception( cancellation );
+        throwResume except;
+        except.the_exception->virtual_table->free( except.the_exception );
+        free( cancellation );
+        desc->self_cor.cancellation = 0p;
+}
+void ^?{}( thread_dtor_guard_t & this ) {
+        ^(this.mg){};
+}
 //-----------------------------------------------------------------------------
 // Starting and stopping threads
 …
         verify( this_thrd->context.SP );
         __schedule_thread( (__processor_id_t *)kernelTLS.this_processor, this_thrd);
+        __schedule_thread( this_thrd );
         enable_interrupts( __cfaabi_dbg_ctx );
+}
 …
+}
+//-----------------------------------------------------------------------------
+forall(dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)))
+T & join( T & this ) {
+        thread_dtor_guard_t guard = { this, defaultResumptionHandler };
+        return this;
+}
 // Local Variables: //
 // mode: c //

libcfa/src/concurrency/thread.hfa

-              r4b30e8cc
+              rc28ea4e
 #include "kernel.hfa"
 #include "monitor.hfa"
+#include "exception.hfa"
 //-----------------------------------------------------------------------------
 // thread trait
 trait is_thread(dtype T) {
       void ^?{}(T& mutex this);
       void main(T& this);
       $thread* get_thread(T& this);
+        void ^?{}(T& mutex this);
+        void main(T& this);
+        $thread* get_thread(T& this);
 };
+FORALL_DATA_EXCEPTION(ThreadCancelled, (dtype thread_t), (thread_t)) (
+        thread_t * the_thread;
+        exception_t * the_exception;
+);
+forall(dtype T)
+void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src);
+forall(dtype T)
+const char * msg(ThreadCancelled(T) *);
 // define that satisfies the trait without using the thread keyword
 …
 static inline void ?{}($thread & this, const char * const name, struct cluster & cl )                   { this{ name, cl, 0p, 65000 }; }
 static inline void ?{}($thread & this, const char * const name, struct cluster & cl, size_t stackSize ) { this{ name, cl, 0p, stackSize }; }
+struct thread_dtor_guard_t {
+        monitor_dtor_guard_t mg;
+};
+forall( dtype T | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) )
+void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
+void ^?{}( thread_dtor_guard_t & this );
 //-----------------------------------------------------------------------------
 …
 //----------
 // join
 forall( dtype T | is_thread(T) )
+forall( dtype T | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) )
 T & join( T & this );

libcfa/src/exception.c

-              r4b30e8cc
+              rc28ea4e
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug 29 15:52:22 2020
 // Update Count     : 34
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct 27 16:27:00 2020
+// Update Count     : 35
 //
 …
 #include <stddef.h> // for size_t
+#include <unwind.h> // for struct _Unwind_Exception {...};
 #include "exception.h"
 #include <stdlib.h>
 #include <stdio.h>
-#include <unwind.h>
 #include <bits/debug.hfa>
 #include "concurrency/invoke.h"
 …
 // MEMORY MANAGEMENT =========================================================
-struct __cfaehm_node {
-        struct _Unwind_Exception unwind_exception;
-        struct __cfaehm_node * next;
-        int handler_index;
-};
 #define NODE_TO_EXCEPT(node) ((exception_t *)(1 + (node)))

libcfa/src/exception.h

-              r4b30e8cc
+              rc28ea4e
 // file "LICENCE" distributed with Cforall.
 //
 // exception.h -- Builtins for exception handling.
+// exception.h -- Internal exception handling definitions.
 //
 // Author           : Andrew Beach
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue May 19 14:17:00 2020
 // Update Count     : 10
+// Last Modified On : Tue Oct 27 14:45:00 2020
+// Update Count     : 11
 //
 #pragma once
+// This could be considered several headers. All are internal to the exception
+// system but needed to depending on whether they are C/Cforall code and
+// whether or not they are part of the builtins.
 #ifdef __cforall
 extern "C" {
 #endif
+// Included in C code or the built-ins.
+#if !defined(__cforall) || defined(__cforall_builtins__)
 struct __cfaehm_base_exception_t;
 …
 // Function catches termination exceptions.
 void __cfaehm_try_terminate(
     void (*try_block)(),
     void (*catch_block)(int index, exception_t * except),
     int (*match_block)(exception_t * except));
+        void (*try_block)(),
+        void (*catch_block)(int index, exception_t * except),
+        int (*match_block)(exception_t * except));
 // Clean-up the exception in catch blocks.
 …
 // Data structure creates a list of resume handlers.
 struct __cfaehm_try_resume_node {
     struct __cfaehm_try_resume_node * next;
     _Bool (*handler)(exception_t * except);
+        struct __cfaehm_try_resume_node * next;
+        _Bool (*handler)(exception_t * except);
 };
 // These act as constructor and destructor for the resume node.
 void __cfaehm_try_resume_setup(
     struct __cfaehm_try_resume_node * node,
     _Bool (*handler)(exception_t * except));
+        struct __cfaehm_try_resume_node * node,
+        _Bool (*handler)(exception_t * except));
 void __cfaehm_try_resume_cleanup(
     struct __cfaehm_try_resume_node * node);
+        struct __cfaehm_try_resume_node * node);
 // Check for a standard way to call fake deconstructors.
 struct __cfaehm_cleanup_hook {};
+#endif
+// Included in C code and the library.
+#if !defined(__cforall) || !defined(__cforall_builtins__)
+struct __cfaehm_node {
+        struct _Unwind_Exception unwind_exception;
+        struct __cfaehm_node * next;
+        int handler_index;
+};
+static inline exception_t * __cfaehm_cancellation_exception(
+                struct _Unwind_Exception * unwind_exception ) {
+        return (exception_t *)(1 + (struct __cfaehm_node *)unwind_exception);
+}
+#endif
 #ifdef __cforall
+}
+// Built-ins not visible in C.
+#if defined(__cforall_builtins__)
 // Not all the built-ins can be expressed in C. These can't be
 …
 #endif
+#endif

libcfa/src/stdlib.cfa

-              r4b30e8cc
+              rc28ea4e
 forall( dtype T | sized(T) | { void ^?{}( T & ); } )
 void adelete( size_t dim, T arr[] ) {
+void adelete( T arr[] ) {
         if ( arr ) {                                                                            // ignore null
+                size_t dim = malloc_size( arr ) / sizeof( T );
                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
                         ^(arr[i]){};                                                            // run destructor
 …
 forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } )
 void adelete( size_t dim, T arr[], Params rest ) {
+void adelete( T arr[], Params rest ) {
         if ( arr ) {                                                                            // ignore null
+                size_t dim = malloc_size( arr ) / sizeof( T );
                 for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
                         ^(arr[i]){};                                                            // run destructor

libcfa/src/stdlib.hfa

-              r4b30e8cc
+              rc28ea4e
 // Cforall allocation/deallocation and constructor/destructor, array types
 forall( dtype T | sized(T), ttype Params | { void ?{}( T &, Params ); } ) T * anew( size_t dim, Params p );
 forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( size_t dim, T arr[] );
 forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( size_t dim, T arr[], Params rest );
+forall( dtype T | sized(T) | { void ^?{}( T & ); } ) void adelete( T arr[] );
+forall( dtype T | sized(T) | { void ^?{}( T & ); }, ttype Params | { void adelete( Params ); } ) void adelete( T arr[], Params rest );
 //---------------------------------------

src/AST/Convert.cpp

-              r4b30e8cc
+              rc28ea4e
 #include "AST/Init.hpp"
 #include "AST/Stmt.hpp"
+#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 …
 //================================================================================================
 namespace {
+namespace ast {
 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
+// xxx - since convert back pass works, this concern seems to be unnecessary.
+// these need to be accessed in new FixInit now
 ast::Type * sizeType = nullptr;
 ast::FunctionDecl * dereferenceOperator = nullptr;
 …
         using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
         Cache cache;
+        // Statements can no longer be shared.
+        // however, since StmtExprResult is now implemented, need to still maintain
+        // readonly references.
+        Cache readonlyCache;
         template<typename T>
 …
+        }
+        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
+                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto&& type = get<Type>().accept1( node->type );
+                auto&& init = get<Initializer>().accept1( node->init );
+                auto&& attr = get<Attribute>().acceptL( node->attributes );
+        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
                 if ( inCache( node ) ) {
                         return nullptr;
+                }
+                auto bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto type = get<Type>().accept1( node->type );
+                auto attr = get<Attribute>().acceptL( node->attributes );
                 auto decl = new ObjectDecl(
                         node->name,
 …
                         bfwd,
                         type->clone(),
                         init,
+                        nullptr, // prevent infinite loop
                         attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
+                return declWithTypePostamble( decl, node );
+                // handles the case where node->init references itself
+                // xxx - does it really happen?
+                declWithTypePostamble(decl, node);
+                auto init = get<Initializer>().accept1( node->init );
+                decl->init = init;
+                this->node = decl;
+                return nullptr;
+        }
 …
                 decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
                 if ( dereferenceOperator == node ) {
+                if ( ast::dereferenceOperator == node ) {
                         Validate::dereferenceOperator = decl;
+                }
                 if ( dtorStructDestroy == node ) {
+                if ( ast::dtorStructDestroy == node ) {
                         Validate::dtorStructDestroy = decl;
+                }
 …
                 );
                 if ( dtorStruct == node ) {
+                if ( ast::dtorStruct == node ) {
                         Validate::dtorStruct = decl;
+                }
 …
         const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
+                cache.emplace( node, stmt );
+                // force statements in old tree to be unique.
+                // cache.emplace( node, stmt );
+                readonlyCache.emplace( node, stmt );
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
 …
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new ExprStmt( nullptr );
-                cache.emplace( node, stmt );
                 stmt->expr = get<Expression>().accept1( node->expr );
                 return stmtPostamble( stmt, node );
 …
                 auto stmts = node->stmts;
                 // disable sharing between multiple StmtExprs explicitly.
+                if (inCache(stmts)) {
+                        stmts = ast::deepCopy(stmts.get());
+                }
+                // this should no longer be true.
                 auto rslt = new StmtExpr(
                         get<CompoundStmt>().accept1(stmts)
 …
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
+                if (node->resultExpr) {
+                        // this MUST be found by children visit
+                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
+                }
                 auto expr = visitBaseExpr( node, rslt );
 …
                 auto expr = visitBaseExpr( node, rslt );
                 this->node = expr;
+                this->node = expr->clone();
                 return nullptr;
+        }
 …
                 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
                 // I believe this should always be a BasicType.
                 if ( sizeType == node ) {
+                if ( ast::sizeType == node ) {
                         Validate::SizeType = type;
+                }
 …
 };
 std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
+std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit ) {
         ConverterNewToOld c;
         std::list< Declaration * > decls;
         for(auto d : translationUnit) {
+        for(auto d : translationUnit.decls) {
                 decls.emplace_back( c.decl( d ) );
+        }
 …
                 // function type is now derived from parameter decls instead of storing them
+                /*
                 auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type));
                 ftype->params.reserve(paramVars.size());
 …
+                }
                 ftype->forall = std::move(forall);
+                visitType(old->type, ftype);
+                */
+                // can function type have attributes? seems not to be the case.
+                // visitType(old->type, ftype);
                 auto decl = new ast::FunctionDecl{
 …
                         old->name,
                         // GET_ACCEPT_1(type, FunctionType),
+                        std::move(forall),
                         std::move(paramVars),
                         std::move(returnVars),
 …
                         { old->linkage.val },
                         GET_ACCEPT_V(attributes, Attribute),
+                        { old->get_funcSpec().val }
+                        { old->get_funcSpec().val },
+                        old->type->isVarArgs
                 };
                 decl->type = ftype;
+                // decl->type = ftype;
                 cache.emplace( old, decl );
 …
                 if ( Validate::dereferenceOperator == old ) {
                         dereferenceOperator = decl;
+                        ast::dereferenceOperator = decl;
+                }
                 if ( Validate::dtorStructDestroy == old ) {
                         dtorStructDestroy = decl;
+                        ast::dtorStructDestroy = decl;
+                }
+        }
 …
                 if ( Validate::dtorStruct == old ) {
                         dtorStruct = decl;
+                        ast::dtorStruct = decl;
+                }
+        }
 …
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
                         sizeType = type;
+                        ast::sizeType = type;
+                }
                 visitType( old, type );
 …
 #undef GET_ACCEPT_1
 std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
+ast::TranslationUnit convert( const std::list< Declaration * > && translationUnit ) {
         ConverterOldToNew c;
         std::list< ast::ptr< ast::Decl > > decls;
+        ast::TranslationUnit unit;
         for(auto d : translationUnit) {
                 d->accept( c );
                 decls.emplace_back( c.decl() );
+                unit.decls.emplace_back( c.decl() );
+        }
         deleteAll(translationUnit);
         return decls;
+        return unit;
+}

src/AST/Convert.hpp

-              r4b30e8cc
+              rc28ea4e
 #include <list>
-#include "AST/Node.hpp"
 class Declaration;
 namespace ast {
         class Decl;
+        class TranslationUnit;
 };
 std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit );
 std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit );
+std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit );
+ast::TranslationUnit convert( const std::list< Declaration * > && translationUnit );

src/AST/Decl.cpp

-              r4b30e8cc
+              rc28ea4e
 // --- FunctionDecl
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name,
+                std::vector<ptr<TypeDecl>>&& forall,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+                CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+                std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+          stmts( stmts ) {
+                  FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+                  for (auto & param : this->params) {
+                          ftype->params.emplace_back(param->get_type());
+                  }
+                  for (auto & ret : this->returns) {
+                          ftype->returns.emplace_back(ret->get_type());
+                  }
+                  ftype->forall = std::move(forall);
+                  this->type = ftype;
+          }
 const Type * FunctionDecl::get_type() const { return type.get(); }

src/AST/Decl.hpp

-              r4b30e8cc
+              rc28ea4e
         std::vector< ptr<Expr> > withExprs;
         FunctionDecl( const CodeLocation & loc, const std::string & name,
+        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
                 std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
                 std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
         : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
           stmts( stmts ) {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+        //  stmts( stmts ) {}
         const Type * get_type() const override;

src/AST/DeclReplacer.cpp

-              r4b30e8cc
+              rc28ea4e
                         const ast::TypeInstType * previsit( const ast::TypeInstType * );
                 };
+                struct VarExprReplacer {
+                private:
+                        const ExprMap & exprMap;
+                public:
+                        VarExprReplacer(const ExprMap & exprMap): exprMap (exprMap) {}
+                        const Expr * postvisit (const VariableExpr *);
+                };
+        }
 …
                 DeclMap declMap;
                 return replace( node, declMap, typeMap, debug );
+        }
+        const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap) {
+                Pass<VarExprReplacer> replacer = {exprMap};
+                return node->accept( replacer );
+        }
 …
                         return ninst;
+                }
+                const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
+                        if (!exprMap.count(expr->var)) return expr;
+                        return exprMap.at(expr->var);
+                }
+        }
+}

src/AST/DeclReplacer.hpp

-              r4b30e8cc
+              rc28ea4e
         class DeclWithType;
         class TypeDecl;
+        class Expr;
         namespace DeclReplacer {
                 using DeclMap = std::unordered_map< const DeclWithType *, const DeclWithType * >;
                 using TypeMap = std::unordered_map< const TypeDecl *, const TypeDecl * >;
+                using ExprMap = std::unordered_map< const DeclWithType *, const Expr * >;
                 const Node * replace( const Node * node, const DeclMap & declMap, bool debug = false );
                 const Node * replace( const Node * node, const TypeMap & typeMap, bool debug = false );
                 const Node * replace( const Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+                const Node * replace( const Node * node, const ExprMap & exprMap);
+        }
+}

src/AST/Expr.cpp

-              r4b30e8cc
+              rc28ea4e
 // --- UntypedExpr
 UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, Expr * arg ) {
+UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 …
+}
 UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
+UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 …
+        }
         return ret;
+}
+// --- VariableExpr
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
+: Expr( loc ), var( v ) {
+        assert( var );
+        assert( var->get_type() );
+        result = shallowCopy( var->get_type() );
+}
+bool VariableExpr::get_lvalue() const {
+        // It isn't always an lvalue, but it is never an rvalue.
+        return true;
+}
+VariableExpr * VariableExpr::functionPointer(
+                const CodeLocation & loc, const FunctionDecl * decl ) {
+        // wrap usually-determined result type in a pointer
+        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
+        funcExpr->result = new PointerType{ funcExpr->result };
+        return funcExpr;
+}
 …
+}
-// --- VariableExpr
-VariableExpr::VariableExpr( const CodeLocation & loc )
-: Expr( loc ), var( nullptr ) {}
-VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
-: Expr( loc ), var( v ) {
-        assert( var );
-        assert( var->get_type() );
-        result = shallowCopy( var->get_type() );
+}
-bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
+}
-VariableExpr * VariableExpr::functionPointer(
-                const CodeLocation & loc, const FunctionDecl * decl ) {
-        // wrap usually-determined result type in a pointer
-        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
-        funcExpr->result = new PointerType{ funcExpr->result };
-        return funcExpr;
+}
 // --- ConstantExpr

src/AST/Expr.hpp

-              r4b30e8cc
+              rc28ea4e
         /// Creates a new dereference expression
         static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
         /// Creates a new assignment expression
         static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 …
 private:
         NameExpr * clone() const override { return new NameExpr{ *this }; }
+        MUTATE_FRIEND
+};
+/// A reference to a named variable.
+class VariableExpr final : public Expr {
+public:
+        readonly<DeclWithType> var;
+        VariableExpr( const CodeLocation & loc );
+        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+        bool get_lvalue() const final;
+        /// generates a function pointer for a given function
+        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
         MUTATE_FRIEND
 };
 …
 };
-/// A reference to a named variable.
-class VariableExpr final : public Expr {
-public:
-        readonly<DeclWithType> var;
-        VariableExpr( const CodeLocation & loc );
-        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
-        bool get_lvalue() const final;
-        /// generates a function pointer for a given function
-        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
-        MUTATE_FRIEND
-};
 /// A compile-time constant.
 /// Mostly carries C-source text from parse to code-gen, without interpretation.  E.g. strings keep their outer quotes and never have backslashes interpreted.
 …
                 const CodeLocation & loc, const Type * ty, const std::string & r,
                         std::optional<unsigned long long> i )
         : Expr( loc, ty ), rep( r ), ival( i ) {}
+        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
         /// Gets the integer value of this constant, if one is appropriate to its type.
 …
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
         : Expr( loc, call->result ) { assert( call ); }
+        : Expr( loc, call->result ), callExpr(call) { assert( call ); assert(call->result); }
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 …
         std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
+        readonly<ExprStmt> resultExpr;
         StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );

src/AST/Fwd.hpp

-              r4b30e8cc
+              rc28ea4e
 typedef unsigned int UniqueId;
+class TranslationUnit;
+// TODO: Get from the TranslationUnit:
+extern Type * sizeType;
+extern FunctionDecl * dereferenceOperator;
+extern StructDecl   * dtorStruct;
+extern FunctionDecl * dtorStructDestroy;
+}

src/AST/Node.hpp

r4b30e8cc	rc28ea4e
49	49
50	50	bool unique() const { return strong_count == 1; }
	51	bool isManaged() const {return strong_count > 0; }
51	52
52	53	private:

src/AST/Pass.hpp

-              r4b30e8cc
+              rc28ea4e
         /// Construct and run a pass on a translation unit.
         template< typename... Args >
         static void run( std::list< ptr<Decl> > & decls, Args &&... args ) {
+        static void run( TranslationUnit & decls, Args &&... args ) {
                 Pass<core_t> visitor( std::forward<Args>( args )... );
                 accept_all( decls, visitor );
 …
         // Versions of the above for older compilers.
         template< typename... Args >
         static void run( std::list< ptr<Decl> > & decls ) {
+        static void run( TranslationUnit & decls ) {
                 Pass<core_t> visitor;
                 accept_all( decls, visitor );
 …
         template<typename core_type>
         friend void accept_all( std::list< ptr<Decl> > & decls, Pass<core_type>& visitor );
+        bool isInFunction() const {
+                return inFunction;
+        }
 private:
 …
         const ast::Stmt * call_accept( const ast::Stmt * );
         const ast::Expr * call_accept( const ast::Expr * );
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
         template< typename node_t >
 …
         template<typename node_t, typename parent_t, typename child_t>
         void maybe_accept(const node_t * &, child_t parent_t::* child);
+        template<typename node_t, typename parent_t, typename child_t>
+        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
 private:
 …
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 };
 …
 template<typename core_t>
 void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<core_t> & visitor );
+template<typename core_t>
+void accept_all( ast::TranslationUnit &, ast::Pass<core_t> & visitor );
 //-------------------------------------------------------------------------------------------------
 …
 struct WithVisitorRef {
         Pass<core_t> * const visitor = nullptr;
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };

src/AST/Pass.impl.hpp

-              r4b30e8cc
+              rc28ea4e
 #include <unordered_map>
+#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 …
                 __pedantic_pass_assert( stmt );
+                return stmt->accept( *this );
+        }
+        template< typename core_t >
+        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+                __pedantic_pass_assert( __visit_children() );
+                __pedantic_pass_assert( stmt );
                 // add a few useful symbols to the scope
                 using __pass::empty;
 …
+        }
+        template< typename core_t >
+        template<typename node_t, typename parent_t, typename child_t>
+        void ast::Pass< core_t >::maybe_accept_as_compound(
+                const node_t * & parent,
+                child_t parent_t::*child
+        ) {
+                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
+                if(__pass::skip(parent->*child)) return;
+                const auto & old_val = __pass::get(parent->*child, 0);
+                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
+                auto new_val = call_accept_as_compound( old_val );
+                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
+                if( __pass::differs(old_val, new_val) ) {
+                        auto new_parent = __pass::mutate<core_t>(parent);
+                        new_parent->*child = new_val;
+                        parent = new_parent;
+                }
+        }
         template< typename core_t >
 …
         pass_visitor_stats.depth--;
         if ( !errors.isEmpty() ) { throw errors; }
+}
+template< typename core_t >
+inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
+        return ast::accept_all( unit.decls, visitor );
+}
 …
                                 // foralls are still in function type
                                 maybe_accept( node, &FunctionDecl::type );
+                                // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                                // a new scope if inFunction is true
+                                // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
                                 inFunction = true;
+                                // The function body needs to have the same scope as parameters.
+                                // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                                atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
 …
 const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
         VISIT_START( node );
         VISIT({
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
                         if ( ! inFunctionCpy ) __pass::symtab::enter(core, 0);
                 }, [this, inFunctionCpy = this->inFunction]() {
                         if ( ! inFunctionCpy ) __pass::symtab::leave(core, 0);
+        VISIT(
+                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
+                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
+                        if ( enterScope ) __pass::symtab::enter(core, 0);
+                }, [this, leaveScope = !this->atFunctionTop]() {
+                        if ( leaveScope ) __pass::symtab::leave(core, 0);
                 });
+                ValueGuard< bool > guard2( inFunction );
+                ValueGuard< bool > guard2( atFunctionTop );
+                atFunctionTop = false;
                 guard_scope guard3 { *this };
-                inFunction = false;
                 maybe_accept( node, &CompoundStmt::kids );
         })
+        )
         VISIT_END( CompoundStmt, node );
+}
 …
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
                 maybe_accept( node, &IfStmt::thenPart );
                 maybe_accept( node, &IfStmt::elsePart );
+                maybe_accept_as_compound( node, &IfStmt::thenPart );
+                maybe_accept_as_compound( node, &IfStmt::elsePart );
         })
 …
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
                 maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 …
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
+                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
                 maybe_accept( node, &ForStmt::inits );
                 maybe_accept( node, &ForStmt::cond  );
                 maybe_accept( node, &ForStmt::inc   );
                 maybe_accept( node, &ForStmt::body  );
+                maybe_accept_as_compound( node, &ForStmt::body  );
         })
 …
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
                 maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })

src/AST/Pass.proto.hpp

r4b30e8cc	rc28ea4e
22	22	template<typename core_t>
23	23	class Pass;
	24
	25	class TranslationUnit;
24	26
25	27	struct PureVisitor;

src/AST/SymbolTable.cpp

-              r4b30e8cc
+              rc28ea4e
+}
+/*
 void SymbolTable::addFunctionType( const FunctionType * ftype ) {
         addTypes( ftype->forall );
         addIds( ftype->returns );
         addIds( ftype->params );
+}
+*/
+void SymbolTable::addFunction( const FunctionDecl * func ) {
+        addTypes( func->type->forall );
+        addIds( func->returns );
+        addIds( func->params );
+}
 void SymbolTable::lazyInitScope() {

src/AST/SymbolTable.hpp

r4b30e8cc	rc28ea4e
145	145
146	146	/// convenience function for adding all of the declarations in a function type to the indexer
147		~~// void addFunctionType( const FunctionType * ftype~~ );
	147	void addFunction( const FunctionDecl * );
148	148
149	149	private:

src/AST/Type.cpp

-              r4b30e8cc
+              rc28ea4e
 template<typename decl_t>
+SueInstType<decl_t>::SueInstType(
+        const base_type * b, std::vector<ptr<Expr>> && params,
+        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
+: BaseInstType( b->name, std::move(params), q, std::move(as) ), base( b ) {}
+template<typename decl_t>
 bool SueInstType<decl_t>::isComplete() const {
         return base ? base->body : false;

src/AST/Type.hpp

-              r4b30e8cc
+              rc28ea4e
 class FunctionType final : public ParameterizedType {
 public:
-//      std::vector<ptr<DeclWithType>> returns;
-//      std::vector<ptr<DeclWithType>> params;
         std::vector<ptr<Type>> returns;
         std::vector<ptr<Type>> params;
 …
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
+        BaseInstType(
+                const std::string& n, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : ParameterizedType(q, std::move(as)), params(std::move(params)), name(n) {}
         BaseInstType( const BaseInstType & o );
 …
         SueInstType(
+                const decl_t * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+                const base_type * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+        SueInstType(
+                const base_type * b, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
         bool isComplete() const override;

src/AST/porting.md

-              r4b30e8cc
+              rc28ea4e
   * Base nodes now override `const Node * accept( Visitor & v ) const = 0` with, e.g. `const Stmt * accept( Visitor & v ) const override = 0`
 * `PassVisitor` is replaced with `ast::Pass`
+  * Most one shot uses can use `ast::Pass::run` and `ast::Pass::read`.
+`WithConstTypeSubstitution`
+* `env` => `typeSubs`
 ## Structural Changes ##
 …
   * allows `newObject` as just default settings
+`FunctionDecl`
+* `params` and `returns` added.
+  * Contain the declarations of the parameters and return variables.
+  * Types should match (even be shared with) the fields of `type`.
 `NamedTypeDecl`
 * `parameters` => `params`
 …
 `AggregateDecl`
 * `parameters` => `params`
+`StructDecl`
+* `makeInst` replaced by better constructor on `StructInstType`.
 `Expr`
 …
 * **TODO** move `kind`, `typeNames` into code generator
 `ReferenceToType`
+`ReferenceToType` => `BaseInstType`
 * deleted `get_baseParameters()` from children
   * replace with `aggr() ? aggr()->params : nullptr`
 …
 * `returnVals` => `returns`
 * `parameters` => `params`
+  * Both now just point at types.
 * `bool isVarArgs;` => `enum ArgumentFlag { FixedArgs, VariableArgs }; ArgumentFlag isVarArgs;`
+`SueInstType`
+* Template class, with specializations and using to implement some other types:
+  * `StructInstType`, `UnionInstType` & `EnumInstType`
 `TypeInstType`

src/Common/PassVisitor.h

-              r4b30e8cc
+              rc28ea4e
         virtual TypeSubstitution * mutate( TypeSubstitution * sub ) final;
+        bool isInFunction() const {
+                return inFunction;
+        }
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
         template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
 …
 public:
         PassVisitor<pass_type> * const visitor = nullptr;
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };

src/Common/PassVisitor.impl.h

-              r4b30e8cc
+              rc28ea4e
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
 …
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
 …
                         indexerAddId( &func );
                         maybeMutate_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        // First remember that we are now within a function.
                         ValueGuard< bool > oldInFunction( inFunction );
                         inFunction = true;
+                        // The function body needs to have the same scope as parameters.
+                        // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                        ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                        atFunctionTop = true;
                         maybeMutate_impl( node->statements, *this );
                         maybeMutate_impl( node->attributes, *this );
 …
         VISIT_START( node );
+        {
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 ValueGuard< bool > oldInFunction( inFunction );
                 auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
                 inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
+        }
 …
         VISIT_START( node );
+        {
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 ValueGuard< bool > oldInFunction( inFunction );
                 auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
                 inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
+        }
 …
         MUTATE_START( node );
+        {
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 ValueGuard< bool > oldInFunction( inFunction );
                 auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
                 inFunction = false;
+                atFunctionTop = false;
                 mutateStatementList( node->kids );
+        }

src/Common/utility.h

-              r4b30e8cc
+              rc28ea4e
         reverse_iterate_t( T & ref ) : ref(ref) {}
+        typedef typename T::reverse_iterator iterator;
+        iterator begin() { return ref.rbegin(); }
+        iterator end() { return ref.rend(); }
+        // this does NOT work on const T!!!
+        // typedef typename T::reverse_iterator iterator;
+        auto begin() { return ref.rbegin(); }
+        auto end() { return ref.rend(); }
 };

src/Concurrency/Keywords.cc

-              r4b30e8cc
+              rc28ea4e
+        }
+        // Only detects threads constructed with the keyword thread.
+        inline static bool isThread( DeclarationWithType * decl ) {
+                Type * baseType = decl->get_type()->stripDeclarator();
+                StructInstType * instType = dynamic_cast<StructInstType *>( baseType );
+                if ( nullptr == instType ) { return false; }
+                return instType->baseStruct->is_thread();
+        }
         //=============================================================================================
         // Pass declarations
 …
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
                         "",
+                        "ThreadCancelled",
                         true,
                         AggregateDecl::Thread
 …
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
                 void validate( DeclarationWithType * );
+                void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
                 static void implement( std::list< Declaration * > & translationUnit ) {
 …
                 StructDecl* guard_decl = nullptr;
                 StructDecl* dtor_guard_decl = nullptr;
+                StructDecl* thread_guard_decl = nullptr;
                 static std::unique_ptr< Type > generic_func;
 …
                 bool first = false;
                 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
                 bool isDtor = CodeGen::isDestructor( decl->name );
+                bool const isDtor = CodeGen::isDestructor( decl->name );
                 // Is this function relevant to monitors
 …
                 // Instrument the body
+                if( isDtor ) {
+                        addDtorStatments( decl, body, mutexArgs );
+                if ( isDtor && isThread( mutexArgs.front() ) ) {
+                        if( !thread_guard_decl ) {
+                                SemanticError( decl, "thread destructor requires threads to be in scope, add #include <thread.hfa>\n" );
+                        }
+                        addThreadDtorStatements( decl, body, mutexArgs );
+                }
+                else if ( isDtor ) {
+                        addDtorStatements( decl, body, mutexArgs );
+                }
                 else {
                         addStatments( decl, body, mutexArgs );
+                        addStatements( decl, body, mutexArgs );
+                }
+        }
 …
                         assert( !dtor_guard_decl );
                         dtor_guard_decl = decl;
+                }
+                else if( decl->name == "thread_dtor_guard_t" && decl->body ) {
+                        assert( !thread_guard_decl );
+                        thread_guard_decl = decl;
+                }
+        }
 …
+        }
         void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+        void MutexKeyword::addDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 Type * arg_type = args.front()->get_type()->clone();
                 arg_type->set_mutex( false );
 …
                 //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+                body->push_front( new DeclStmt( monitors) );
+        }
+        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+                body->push_front( new DeclStmt( monitors ) );
+        }
+        void MutexKeyword::addThreadDtorStatements(
+                        FunctionDecl*, CompoundStmt * body,
+                        const std::list<DeclarationWithType * > & args ) {
+                assert( args.size() == 1 );
+                DeclarationWithType * arg = args.front();
+                Type * arg_type = arg->get_type()->clone();
+                assert( arg_type->get_mutex() );
+                arg_type->set_mutex( false );
+                // thread_dtor_guard_t __guard = { this, intptr( 0 ) };
+                body->push_front(
+                        new DeclStmt( new ObjectDecl(
+                                "__guard",
+                                noStorageClasses,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new StructInstType(
+                                        noQualifiers,
+                                        thread_guard_decl
+                                ),
+                                new ListInit(
+                                        {
+                                                new SingleInit( new CastExpr( new VariableExpr( arg ), arg_type ) ),
+                                                new SingleInit( new UntypedExpr(
+                                                        new NameExpr( "intptr" ), {
+                                                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                                        }
+                                                ) ),
+                                        },
+                                        noDesignators,
+                                        true
+                                )
+                        ))
+                );
+        }
+        void MutexKeyword::addStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",

src/GenPoly/GenPoly.cc

-              r4b30e8cc
+              rc28ea4e
+                }
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, env)) return true;
+                        }
+                        return false;
+                }
                 /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
                 bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
 …
+                }
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, tyVars, env)) return true;
+                        }
+                        return false;
+                }
                 /// Checks a parameter list for dynamic-layout parameters from tyVars; will substitute according to env if present
                 bool hasDynParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
 …
                         Type *newType = env->lookup( typeInst->get_name() );
                         if ( newType ) return newType;
+                }
+                return type;
+        }
+        const ast::Type * replaceTypeInst(const ast::Type * type, const ast::TypeSubstitution * env) {
+                if (!env) return type;
+                if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
+                        auto newType = env->lookup(typeInst->name);
+                        if (newType) return newType;
+                }
                 return type;
 …
+        }
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+                if ( dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return type;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return 0;
+        }
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
 …
+                }
                 return 0;
+        }
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+                if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return tyVars.find(typeInst->name) != tyVars.end() ? type : nullptr;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return nullptr;
+        }
 …
+        }
+        namespace {
+                // temporary hack to avoid re-implementing anything related to TyVarMap
+                // does this work? these two structs have identical definitions.
+                inline TypeDecl::Data convData(const ast::TypeDecl::Data & data) {
+                        return *reinterpret_cast<const TypeDecl::Data *>(&data);
+                }
+        }
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
 …
+        }
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env) {
+                // is parameter is not polymorphic, don't need to box
+                if ( ! isPolyType( param, exprTyVars ) ) return false;
+                ast::ptr<ast::Type> newType = arg;
+                if ( env ) env->apply( newType );
+                // if the argument's type is polymorphic, we don't need to box again!
+                return ! isPolyType( newType );
+        }
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
                 FunctionType * function = getFunctionType( appExpr->function->result );
 …
+        }
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env) {
+                const ast::FunctionType * function = getFunctionType(appExpr->func->result);
+                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->func->result ).c_str() );
+                TyVarMap exprTyVars(TypeDecl::Data{});
+                makeTyVarMap(function, exprTyVars);
+                return needsBoxing(param, arg, exprTyVars, env);
+        }
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
+        }
+        void addToTyVarMap( const ast::TypeDecl * tyVar, TyVarMap & tyVarMap) {
+                tyVarMap.insert(tyVar->name, convData(ast::TypeDecl::Data{tyVar}));
+        }
 …
                 if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
                         makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
+        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
+                if (auto ptype = dynamic_cast<const ast::ParameterizedType *>(type)) {
+                        for (auto & tyVar : ptype->forall) {
+                                assert (tyVar);
+                                addToTyVarMap(tyVar, tyVarMap);
+                        }
+                }
+                if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
+                        makeTyVarMap(pointer->base, tyVarMap);
+                }
+        }

src/GenPoly/GenPoly.h

-              r4b30e8cc
+              rc28ea4e
 namespace GenPoly {
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
         Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
 …
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env = nullptr);
         /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env = nullptr);
         /// returns dynamic-layout type if is dynamic-layout type in tyVars, NULL otherwise; will look up substitution in env if provided
 …
         /// true if arg requires boxing given exprTyVars
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env );
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env);
         /// true if arg requires boxing in the call to appExpr
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env );
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env);
         /// Adds the type variable `tyVar` to `tyVarMap`
 …
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
+        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap);
         /// Prints type variable map

src/GenPoly/Specialize.cc

-              r4b30e8cc
+              rc28ea4e
                 thunkFunc->get_attributes().push_back( new Attribute( "unused" ) );
+                // Thunks at the global level must be static to avoid collisions between files.
+                // (Conversly thunks inside a function must be unique and not static.)
+                thunkFunc->storageClasses.is_static = !isInFunction();
                 // thread thunk parameters into call to actual function, naming thunk parameters as we go
                 UniqueName paramNamer( paramPrefix );

src/InitTweak/FixGlobalInit.cc

-              r4b30e8cc
+              rc28ea4e
 #include "SynTree/Visitor.h"       // for acceptAll, Visitor
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
 namespace InitTweak {
         class GlobalFixer : public WithShortCircuiting {
 …
                 FunctionDecl * initFunction;
                 FunctionDecl * destroyFunction;
+        };
+        class GlobalFixer_new : public ast::WithShortCircuiting {
+        public:
+                void previsit (const ast::ObjectDecl *);
+                void previsit (const ast::FunctionDecl *) { visit_children = false; }
+                void previsit (const ast::StructDecl *) { visit_children = false; }
+                void previsit (const ast::UnionDecl *) { visit_children = false; }
+                void previsit (const ast::EnumDecl *) { visit_children = false; }
+                void previsit (const ast::TraitDecl *) { visit_children = false; }
+                void previsit (const ast::TypeDecl *) { visit_children = false; }
+                std::list< ast::ptr<ast::Stmt> > initStmts;
+                std::list< ast::ptr<ast::Stmt> > destroyStmts;
         };
 …
+        }
+        void fixGlobalInit(ast::TranslationUnit & translationUnit, bool inLibrary) {
+                ast::Pass<GlobalFixer_new> fixer;
+                accept_all(translationUnit, fixer);
+                if ( !fixer.core.initStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> ctorParams;
+                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto initFunction = new ast::FunctionDecl({}, "__global_init__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.initStmts)),
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("constructor", std::move(ctorParams))});
+                        translationUnit.decls.emplace_back( initFunction );
+                } // if
+                if ( !fixer.core.destroyStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> dtorParams;
+                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto destroyFunction = new ast::FunctionDecl({}, "__global_destroy__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.destroyStmts)),
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("destructor", std::move(dtorParams))});
+                        translationUnit.decls.emplace_back(destroyFunction);
+                } // if
+        }
         void GlobalFixer::previsit( ObjectDecl *objDecl ) {
                 std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
 …
                         } // if
                         if ( Statement * ctor = ctorInit->ctor ) {
+                                // Translation 1: Add this attribute on the global declaration:
+                                //    __attribute__((section (".data#")))
+                                // which makes gcc put the global in the data section,
+                                // so that the global is writeable (via a const cast) in the init function.
+                                // The trailing # is an injected assembly comment, to suppress the "a" in
+                                //    .section .data,"a"
+                                //    .section .data#,"a"
+                                // to avoid assembler warning "ignoring changed section attributes for .data"
+                                Type *strLitT = new PointerType( Type::Qualifiers( ),
+                                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
+                                std::list< Expression * > attr_params;
+                                attr_params.push_back(
+                                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
+                                objDecl->attributes.push_back(new Attribute("section", attr_params));
+                                // Translation 2: Move the initizliation off the global declaration,
+                                // into the startup function.
+                                addDataSectonAttribute( objDecl );
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;
 …
+        }
+        void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) {
+                auto mutDecl = mutate(objDecl);
+                assertf(mutDecl == objDecl, "Global object decl must be unique");
+                if ( auto ctorInit = objDecl->init.as<ast::ConstructorInit>() ) {
+                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
+                        assert( ! ctorInit->ctor || ! ctorInit->init );
+                        const ast::Stmt * dtor = ctorInit->dtor;
+                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
+                                // don't need to call intrinsic dtor, because it does nothing, but
+                                // non-intrinsic dtors must be called
+                                destroyStmts.push_front( dtor );
+                                // ctorInit->dtor = nullptr;
+                        } // if
+                        if ( const ast::Stmt * ctor = ctorInit->ctor ) {
+                                initStmts.push_back( ctor );
+                                mutDecl->init = nullptr;
+                                // ctorInit->ctor = nullptr;
+                        } else if ( const ast::Init * init = ctorInit->init ) {
+                                mutDecl->init = init;
+                                // ctorInit->init = nullptr;
+                        } else {
+                                // no constructor and no initializer, which is okay
+                                mutDecl->init = nullptr;
+                        } // if
+                        // delete ctorInit;
+                } // if
+        }
         // only modify global variables
         void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }

src/InitTweak/FixGlobalInit.h

-              r4b30e8cc
+              rc28ea4e
 #include <string>  // for string
+#include <AST/Fwd.hpp>
 class Declaration;
 …
         /// function is for library code.
         void fixGlobalInit( std::list< Declaration * > & translationUnit, bool inLibrary );
+        void fixGlobalInit( ast::TranslationUnit & translationUnit, bool inLibrary );
 } // namespace

src/InitTweak/FixInit.cc

-              r4b30e8cc
+              rc28ea4e
                 };
                 struct SplitExpressions : public WithShortCircuiting, public WithTypeSubstitution, public WithStmtsToAdd {
+                struct SplitExpressions : public WithShortCircuiting, /*public WithTypeSubstitution, */public WithStmtsToAdd {
                         /// add CompoundStmts around top-level expressions so that temporaries are destroyed in the correct places.
                         static void split( std::list< Declaration * > &translationUnit );
 …
                                 if ( Statement * ctor = ctorInit->get_ctor() ) {
                                         if ( objDecl->get_storageClasses().is_static ) {
+                                                // The ojbect needs to go in the data section, regardless of dtor complexity below.
+                                                // The attribute works, and is meant to apply, both for leaving the static local alone,
+                                                // and for hoisting it out as a static global.
+                                                addDataSectonAttribute( objDecl );
                                                 // originally wanted to take advantage of gcc nested functions, but
                                                 // we get memory errors with this approach. To remedy this, the static

src/InitTweak/FixInit.h

-              r4b30e8cc
+              rc28ea4e
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 namespace InitTweak {
         /// replace constructor initializers with expression statements and unwrap basic C-style initializers
         void fix( std::list< Declaration * > & translationUnit, bool inLibrary );
+        void fix( ast::TranslationUnit & translationUnit, bool inLibrary);
 } // namespace

src/InitTweak/GenInit.cc

-              r4b30e8cc
+              rc28ea4e
                 assert( stmts.size() <= 1 );
                 return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
+        }
+        ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg) {
+                assertf(objDecl, "genCtorDtor passed null objDecl");
+                InitExpander_new srcParam(arg);
+                return SymTab::genImplicitCall(srcParam, new ast::VariableExpr(loc, objDecl), loc, fname, objDecl);
+        }

src/InitTweak/GenInit.h

r4b30e8cc	rc28ea4e
33	33	/// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
34	34	ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
	35	ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg = nullptr);
35	36
36	37	/// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer

src/InitTweak/InitTweak.cc

-              r4b30e8cc
+              rc28ea4e
+        }
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
+                assertf( func, "getParamThis: nullptr ftype" );
+                auto & params = func->params;
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( func ).c_str());
+                return params.front().strict_as<ast::ObjectDecl>();
+        }
         bool tryConstruct( DeclarationWithType * dwt ) {
                 ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
 …
+        }
+        bool tryConstruct( const ast::DeclWithType * dwt ) {
+                auto objDecl = dynamic_cast< const ast::ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
+                return (objDecl->init == nullptr ||
+                                ( objDecl->init != nullptr && objDecl->init->maybeConstructed ))
+                        && ! objDecl->storage.is_extern
+                        && isConstructable( objDecl->type );
+        }
+        bool isConstructable( const ast::Type * type ) {
+                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type )
+                && ! dynamic_cast< const ast::FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
         struct CallFinder_old {
                 CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
 …
         struct CallFinder_new final {
                 std::vector< ast::ptr< ast::Expr > > matches;
+                std::vector< const ast::Expr * > matches;
                 const std::vector< std::string > names;
 …
+        }
         std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
 …
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
                         std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
+                        std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
+                }
 …
+        }
+        // looks like some other such codegen uses UntypedExpr and does not create fake function. should revisit afterwards
+        // following passes may accidentally resolve this expression if returned as untyped...
+        ast::Expr * createBitwiseAssignment (const ast::Expr * dst, const ast::Expr * src) {
+                static ast::ptr<ast::FunctionDecl> assign = nullptr;
+                if (!assign) {
+                        auto td = new ast::TypeDecl({}, "T", {}, nullptr, ast::TypeDecl::Dtype, true);
+                        assign = new ast::FunctionDecl({}, "?=?", {},
+                        { new ast::ObjectDecl({}, "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
+                          new ast::ObjectDecl({}, "_src", new ast::TypeInstType("T", td))},
+                        { new ast::ObjectDecl({}, "_ret", new ast::TypeInstType("T", td))}, nullptr, {}, ast::Linkage::Intrinsic);
+                }
+                if (dst->result.as<ast::ReferenceType>()) {
+                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
+                                dst = new ast::AddressExpr(dst);
+                        }
+                }
+                else {
+                        dst = new ast::CastExpr(dst, new ast::ReferenceType(dst->result, {}));
+                }
+                if (src->result.as<ast::ReferenceType>()) {
+                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
+                                src = new ast::AddressExpr(src);
+                        }
+                }
+                return new ast::ApplicationExpr(dst->location, ast::VariableExpr::functionPointer(dst->location, assign), {dst, src});
+        }
         struct ConstExprChecker : public WithShortCircuiting {
                 // most expressions are not const expr
 …
                 return isCopyFunction( decl, "?{}" );
+        }
+        void addDataSectonAttribute( ObjectDecl * objDecl ) {
+                Type *strLitT = new PointerType( Type::Qualifiers( ),
+                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
+                std::list< Expression * > attr_params;
+                attr_params.push_back(
+                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
+                objDecl->attributes.push_back(new Attribute("section", attr_params));
+        }
+}

src/InitTweak/InitTweak.h

-              r4b30e8cc
+              rc28ea4e
         /// returns the first parameter of a constructor/destructor/assignment function
         ObjectDecl * getParamThis( FunctionType * ftype );
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func);
         /// generate a bitwise assignment operation.
         ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
+        ast::Expr * createBitwiseAssignment( const ast::Expr * dst, const ast::Expr * src);
         /// transform Initializer into an argument list that can be passed to a call expression
 …
         /// True if the resolver should try to construct dwt
         bool tryConstruct( DeclarationWithType * dwt );
+        bool tryConstruct( const ast::DeclWithType * dwt );
         /// True if the type can have a user-defined constructor
         bool isConstructable( Type * t );
+        bool isConstructable( const ast::Type * t );
         /// True if the Initializer contains designations
 …
         /// get all Ctor/Dtor call expressions from a Statement
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
         std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt );
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt );
         /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
 …
         bool isConstExpr( Expression * expr );
         bool isConstExpr( Initializer * init );
+        /// Modifies objDecl to have:
+        ///    __attribute__((section (".data#")))
+        /// which makes gcc put the declared variable in the data section,
+        /// which is helpful for global constants on newer gcc versions,
+        /// so that CFA's generated initialization won't segfault when writing it via a const cast.
+        /// The trailing # is an injected assembly comment, to suppress the "a" in
+        ///    .section .data,"a"
+        ///    .section .data#,"a"
+        /// to avoid assembler warning "ignoring changed section attributes for .data"
+        void addDataSectonAttribute( ObjectDecl * objDecl );
         class InitExpander_old {

src/InitTweak/module.mk

-              r4b30e8cc
+              rc28ea4e
         InitTweak/GenInit.h \
         InitTweak/InitTweak.cc \
+        InitTweak/InitTweak.h
+        InitTweak/InitTweak.h \
+        InitTweak/FixInitNew.cpp
 SRCDEMANGLE += \

src/Parser/ParseNode.h

-              r4b30e8cc
+              rc28ea4e
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jul  6 09:33:32 2020
 // Update Count     : 892
+// Last Modified On : Sat Oct 24 03:53:54 2020
+// Update Count     : 895
 //
 …
 struct TypeData;
+class DeclarationNode : public ParseNode {
+  public:
+struct DeclarationNode : public ParseNode {
         // These enumerations must harmonize with their names in DeclarationNode.cc.
         enum BasicType { Void, Bool, Char, Int, Int128,
 …
         bool get_inLine() const { return inLine; }
         DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
+  public:
         DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
 …
 //##############################################################################
+class StatementNode final : public ParseNode {
+  public:
+struct StatementNode final : public ParseNode {
         StatementNode() { stmt = nullptr; }
         StatementNode( Statement * stmt ) : stmt( stmt ) {}
 …
                 os << stmt.get() << std::endl;
+        }
+  private:
         std::unique_ptr<Statement> stmt;
 }; // StatementNode
 …
 Statement * build_finally( StatementNode * stmt );
 Statement * build_compound( StatementNode * first );
+StatementNode * maybe_build_compound( StatementNode * first );
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
 Statement * build_directive( std::string * directive );

src/Parser/StatementNode.cc

-              r4b30e8cc
+              rc28ea4e
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug  4 09:39:25 2018
 // Update Count     : 363
+// Last Modified On : Sat Oct 24 04:20:55 2020
+// Update Count     : 383
 //
 …
 } // build_compound
+// A single statement in a control structure is always converted to a compound statement so subsequent generated code
+// can be placed within this compound statement. Otherwise, code generation has to constantly check for a single
+// statement and wrap it into a compound statement to insert additional code. Hence, all control structures have a
+// conical form for code generation.
+StatementNode * maybe_build_compound( StatementNode * first ) {
+        // Optimization: if the control-structure statement is a compound statement, do not wrap it.
+        // e.g., if (...) {...} do not wrap the existing compound statement.
+        if ( ! dynamic_cast<CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                CompoundStmt * cs = new CompoundStmt();
+                buildMoveList( first, cs->get_kids() );
+                return new StatementNode( cs );
+        } // if
+        return first;
+} // maybe_build_compound
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         std::list< Expression * > out, in;

src/Parser/parser.yy

-              r4b30e8cc
+              rc28ea4e
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Oct  9 18:09:09 2020
 // Update Count     : 4614
+// Last Modified On : Sat Oct 24 08:21:14 2020
+// Update Count     : 4624
 //
 …
         IF '(' if_control_expression ')' statement                      %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, $5, nullptr ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
         | IF '(' if_control_expression ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, $5, $7 ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
+        ;
 …
 case_clause:                                                                                    // CFA
         case_label_list statement                                       { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
+        ;
 …
 iteration_statement:
         WHILE '(' push if_control_expression ')' statement pop
                 { $$ = new StatementNode( build_while( $4, $6 ) ); }
+                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
         | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), $4 ) ); }
+                { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_do_while( $5, $2 ) ); }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), $2 ) ); }
+                { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
         | FOR '(' push for_control_expression_list ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
+                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
+                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+        ;
 …
 waitfor_clause:
         when_clause_opt waitfor statement                                       %prec THEN
                 { $$ = build_waitfor( $2, $3, $1 ); }
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
         | when_clause_opt waitfor statement WOR waitfor_clause
                 { $$ = build_waitfor( $2, $3, $1, $5 ); }
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
         | when_clause_opt timeout statement                                     %prec THEN
                 { $$ = build_waitfor_timeout( $2, $3, $1 ); }
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
         | when_clause_opt ELSE statement
                 { $$ = build_waitfor_timeout( nullptr, $3, $1 ); }
+                { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
                 // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | when_clause_opt timeout statement WOR ELSE statement
                 { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | when_clause_opt timeout statement WOR when_clause ELSE statement
                 { $$ = build_waitfor_timeout( $2, $3, $1, $7, $5 ); }
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
+        ;

src/ResolvExpr/Resolver.cc

-              r4b30e8cc
+              rc28ea4e
+                }
+                /// Establish post-resolver invariants for expressions
+        } // anonymous namespace
+/// Establish post-resolver invariants for expressions
                 void finishExpr(
                         ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
 …
                         StripCasts_new::strip( expr );
+                }
-        } // anonymous namespace
         ast::ptr< ast::Expr > resolveInVoidContext(
 …
+        }
+        namespace {
+                /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
+        /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
                 /// context.
                 ast::ptr< ast::Expr > findVoidExpression(
 …
                         return newExpr;
+                }
+        namespace {
                 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
 …
                         CandidateRef choice =
                                 findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
                         finishExpr( choice->expr, choice->env, untyped->env );
+                        ResolvExpr::finishExpr( choice->expr, choice->env, untyped->env );
                         return std::move( choice->expr );
+                }
 …
         // size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver");
         void resolve( std::list< ast::ptr< ast::Decl > >& translationUnit ) {
+        void resolve( ast::TranslationUnit& translationUnit ) {
                 ast::Pass< Resolver_new >::run( translationUnit );
+        }

src/ResolvExpr/Resolver.h

-              r4b30e8cc
+              rc28ea4e
         class StmtExpr;
         class SymbolTable;
+        class TranslationUnit;
         class Type;
         class TypeEnvironment;
 …
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit );
+        void resolve( ast::TranslationUnit& translationUnit );
         /// Searches expr and returns the first DeletedExpr found, otherwise nullptr
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr );
 …
         ast::ptr< ast::Expr > findSingleExpression(
                 const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab );
+        ast::ptr< ast::Expr > findVoidExpression(
+                const ast::Expr * untyped, const ast::SymbolTable & symtab);
         /// Resolves a constructor init expression
         ast::ptr< ast::Init > resolveCtorInit(
+        ast::ptr< ast::Init > resolveCtorInit(
                 const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab );
         /// Resolves a statement expression
         ast::ptr< ast::Expr > resolveStmtExpr(
+        ast::ptr< ast::Expr > resolveStmtExpr(
                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab );
 } // namespace ResolvExpr

src/SymTab/Autogen.cc

-              r4b30e8cc
+              rc28ea4e
+        }
+        // shallow copy the pointer list for return
+        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams (const ast::Type * t) {
+                if (auto structInst = dynamic_cast<const ast::StructInstType*>(t)) {
+                        return structInst->base->params;
+                }
+                if (auto unionInst = dynamic_cast<const ast::UnionInstType*>(t)) {
+                        return unionInst->base->params;
+                }
+                return {};
+        }
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
 …
                 ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
+        ///
+        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
+                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
+                if (maybePolymorphic) typeParams = getGenericParams(paramType);
+                auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
+                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc));
+        }

src/SymTab/Autogen.h

r4b30e8cc	rc28ea4e
55	55	/// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
56	56	FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
	57
	58	ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic = true);
57	59
58	60	/// generate the type of a copy constructor for paramType.

src/SynTree/Expression.h

-              r4b30e8cc
+              rc28ea4e
 };
+/// VariableExpr represents an expression that simply refers to the value of a named variable.
+/// Does not take ownership of var.
+class VariableExpr : public Expression {
+  public:
+        DeclarationWithType * var;
+        VariableExpr();
+        VariableExpr( DeclarationWithType * var );
+        VariableExpr( const VariableExpr & other );
+        virtual ~VariableExpr();
+        bool get_lvalue() const final;
+        DeclarationWithType * get_var() const { return var; }
+        void set_var( DeclarationWithType * newValue ) { var = newValue; }
+        static VariableExpr * functionPointer( FunctionDecl * decl );
+        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
 // The following classes are used to represent expression types that cannot be converted into
 // function-call format.
 …
 };
-/// VariableExpr represents an expression that simply refers to the value of a named variable.
-/// Does not take ownership of var.
-class VariableExpr : public Expression {
-  public:
-        DeclarationWithType * var;
-        VariableExpr();
-        VariableExpr( DeclarationWithType * var );
-        VariableExpr( const VariableExpr & other );
-        virtual ~VariableExpr();
-        bool get_lvalue() const final;
-        DeclarationWithType * get_var() const { return var; }
-        void set_var( DeclarationWithType * newValue ) { var = newValue; }
-        static VariableExpr * functionPointer( FunctionDecl * decl );
-        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const override { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-};
 /// ConstantExpr represents an expression that simply refers to the value of a constant
 class ConstantExpr : public Expression {

src/main.cc

-              r4b30e8cc
+              rc28ea4e
                         auto transUnit = convert( move( translationUnit ) );
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                        if ( exprp ) {
+                                translationUnit = convert( move( transUnit ) );
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
                         translationUnit = convert( move( transUnit ) );
                 } else {
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                        if ( exprp ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        }
+                        PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
+                }
-                if ( exprp ) {
-                        dump( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
                 // fix ObjectDecl - replaces ConstructorInit nodes
-                PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 if ( ctorinitp ) {
                         dump ( translationUnit );

tests/.expect/const-init.txt

r4b30e8cc	rc28ea4e
1		done
	1	almost done
	2	dtor

tests/Makefile.am

-              r4b30e8cc
+              rc28ea4e
 # adjust CC to current flags
 CC = LC_ALL=C $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) ${ARCH_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CC = LC_ALL=C $(if $(DISTCC_CFA_PATH),distcc $(DISTCC_CFA_PATH) ${ARCH_FLAGS} ${AST_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS} ${AST_FLAGS})
 CFACC = $(CC)
 …
 # adjusted CC but without the actual distcc call
 CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) ${ARCH_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS})
+CFACCLOCAL = $(if $(DISTCC_CFA_PATH),$(DISTCC_CFA_PATH) ${ARCH_FLAGS} ${AST_FLAGS},$(TARGET_CFA) ${DEBUG_FLAGS} ${ARCH_FLAGS} ${AST_FLAGS})
 CFACCLINK = $(CFACCLOCAL) -quiet $(if $(test), 2> $(test), ) $($(shell echo "${@}_FLAGSLD" | sed 's/-\|\//_/g'))

tests/alloc.cfa

r4b30e8cc	rc28ea4e
342	342	for ( i; dim ) { printf( "%d %g, ", stp1[i].x, stp1[i].y ); }
343	343	printf( "\n" );
344		adelete( ~~dim, stp, dim~~, stp1 );
	344	adelete( stp, stp1 );
345	345
346	346	// extras

tests/complex.cfa

r4b30e8cc	rc28ea4e
14	14	//
15	15
16		~~#include <stdio.h>~~
17	16	#include <complex.h>
18	17	#ifdef __CFA__

tests/config.py.in

r4b30e8cc	rc28ea4e
9	9	HOSTARCH = "@host_cpu@"
10	10	DISTRIBUTE = @HAS_DISTCC@
	11	NEWAST = @DEFAULT_NEW_AST@

tests/const-init.cfa

-              r4b30e8cc
+              rc28ea4e
 /*
 This test shows non-crashing of generated code for constants with interesting initizers.
+These tests show non-crashing of generated code for constants with interesting initializers.
 The potential for these to crash is compiler dependent.
 There are two cases:
 . static constants in one compilation unit (tested here)
+. static constants in one compilation unit (tested here, in a few sub-cases)
 . extern constants across compilation units (tested by libcfa being loadable, specifically
    the constant declarations in libcfa/src/limits.cfa, which almost every test exercises,
+   the constant definitions in libcfa/src/limits.cfa, which almost every test exercises,
    including "hello;" but notably, the "limits" test does not exercise it because that test
    is compile-only)
 …
 GCC-10 on Ubuntu 20.04    Has crashed      Has crashed
 For this test case to fail, with most other tests passing, would be a situation only ever
+For this test to fail, with most other tests passing, would be a situation only ever
 observed with GCC-8.
 */
+// initailized by generated function, called before main
 static const char foo = -1;
+struct thing{};
+void ^?{}( thing & ) { printf("dtor\n"); }
 int main() {
+    printf("done\n");
+    // foo is already initialized
+    // no dtor => stays a (static) local, initialized here
+    static const char bar = -1;
+    // has dtor => becomes a global, ctor called here, dtor called at exit
+    static const thing it;
+    printf("almost done\n");
+}

tests/exceptions/cancel/coroutine.cfa

r4b30e8cc	rc28ea4e
1	1	// Try cancelling a coroutine.
2	2
3		~~#include <stdio.h>~~
4	3	#include <coroutine.hfa>
5	4	#include <exception.hfa>

tests/exceptions/conditional.cfa

r4b30e8cc	rc28ea4e
5	5
6	6	#include <exception.hfa>
7		~~#include <stdio.h>~~
8	7
9	8	VTABLE_DECLARATION(num_error)(

tests/exceptions/except-io.hfa

r4b30e8cc	rc28ea4e
1	1	// Common tools for the exception tests.
2
3		~~#include <stdio.h>~~
4	2
5	3	// Echo when a destructor is run and an area/block is left.

tests/exceptions/trash.cfa

r4b30e8cc	rc28ea4e
2	2
3	3	#include <exception.hfa>
4		~~#include <stdio.h>~~
5	4
6	5	TRIVIAL_EXCEPTION(yin);

tests/global-monomorph.cfa

-              r4b30e8cc
+              rc28ea4e
+// Crea
+#include <stdlib.hfa>
+#include <stdio.h>
+// Create monomorphic instances of polymorphic types at global scope.
 forall(dtype T)

tests/poly-d-cycle.cfa

r4b30e8cc	rc28ea4e
1	1	// Check that a cycle of polymorphic dtype structures can be instancated.
2
3		~~#include <stdio.h>~~
4	2
5	3	forall(dtype T)

tests/poly-o-cycle.cfa

r4b30e8cc	rc28ea4e
1	1	// Check that a cycle of polymorphic otype structures can be instancated.
2
3		~~#include <stdio.h>~~
4	2
5	3	forall(otype T)

tests/pybin/settings.py

-              r4b30e8cc
+              rc28ea4e
         def filter(self, tests):
                 return [test for test in tests if not test.arch or self.target == test.arch]
-                return True if not arch else self.target == arch
         @staticmethod
 …
                 self.path   = "debug" if value else "nodebug"
+class AST:
+        def __init__(self, ast):
+                if ast == "new":
+                        self.target = ast
+                        self.string = "New AST"
+                        self.flags  = """AST_FLAGS=-XCFA,--new-ast"""
+                elif ast == "old":
+                        self.target = ast
+                        self.string = "Old AST"
+                        self.flags  = """AST_FLAGS=-XCFA,--old-ast"""
+                elif ast == None:
+                        self.target = "new" if config.NEWAST else "old"
+                        self.string = "Default AST (%s)" % self.target
+                        self.flags  = """AST_FLAGS="""
+                else:
+                        print("""ERROR: Invalid ast configuration, must be "old", "new" or left unspecified, was %s""" % (value), file=sys.stderr)
+                        sys.exit(1)
+        def filter(self, tests):
+                return [test for test in tests if not test.astv or self.target == test.astv]
 class Install:
         def __init__(self, value):
 …
 def init( options ):
+        global all_ast
         global all_arch
         global all_debug
         global all_install
+        global ast
         global arch
+        global debug
         global archive
+        global install
         global continue_
-        global debug
         global dry_run
         global generating
-        global install
         global make
         global output_width
 …
         global timeout2gdb
+        all_ast      = [AST(o)          for o in list(dict.fromkeys(options.ast    ))] if options.ast  else [AST(None)]
         all_arch     = [Architecture(o) for o in list(dict.fromkeys(options.arch   ))] if options.arch else [Architecture(None)]
         all_debug    = [Debug(o)        for o in list(dict.fromkeys(options.debug  ))]

tests/pybin/test_run.py

-              r4b30e8cc
+              rc28ea4e
                 self.path = ''
                 self.arch = ''
+                self.astv = ''
         def toString(self):
                 return "{:25s} ({:5s} {:s})".format( self.name, self.arch if self.arch else "Any", self.target() )
+                return "{:25s} ({:5s} arch, {:s} ast: {:s})".format( self.name, self.arch if self.arch else "Any", self.astv if self.astv else "Any", self.target() )
         def prepare(self):
 …
         def expect(self):
+                return os.path.normpath( os.path.join(settings.SRCDIR  , self.path, ".expect", "%s%s.txt" % (self.name,'' if not self.arch else ".%s" % self.arch)) )
+                arch = '' if not self.arch else ".%s" % self.arch
+                astv = '' if not self.astv else ".nast" if self.astv == "new" else ".oast"
+                return os.path.normpath( os.path.join(settings.SRCDIR  , self.path, ".expect", "%s%s%s.txt" % (self.name,astv,arch)) )
         def error_log(self):
 …
         @staticmethod
         def new_target(target, arch):
+        def new_target(target, arch, astv):
                 test = Test()
                 test.name = os.path.basename(target)
                 test.path = os.path.relpath (os.path.dirname(target), settings.SRCDIR)
                 test.arch = arch.target if arch else ''
+                test.astv = astv.target if astv else ''
                 return test

tests/pybin/tools.py

r4b30e8cc	rc28ea4e
181	181	'-s' if silent else None,
182	182	test_param,
	183	settings.ast.flags,
183	184	settings.arch.flags,
184	185	settings.debug.flags,

tests/test.py

-              r4b30e8cc
+              rc28ea4e
         def match_test(path):
                 match = re.search("^%s\/([\w\/\-_]*).expect\/([\w\-_]+)(\.[\w\-_]+)?\.txt$" % settings.SRCDIR, path)
+                match = re.search("^%s\/([\w\/\-_]*).expect\/([\w\-_]+)(\.nast|\.oast)?(\.[\w\-_]+)?\.txt$" % settings.SRCDIR, path)
                 if match :
                         test = Test()
                         test.name = match.group(2)
                         test.path = match.group(1)
+                        test.arch = match.group(3)[1:] if match.group(3) else None
+                        test.arch = match.group(4)[1:] if match.group(4) else None
+                        astv = match.group(3)[1:] if match.group(3) else None
+                        if astv == 'oast':
+                                test.astv = 'old'
+                        elif astv == 'nast':
+                                test.astv = 'new'
+                        elif astv:
+                                print('ERROR: "%s", expect file has astv but it is not "nast" or "oast"' % testname, file=sys.stderr)
+                                sys.exit(1)
                         expected.append(test)
 …
         if options.regenerate_expected :
                 for testname in options.tests :
+                        testname = canonical_path( testname )
+                        testname = os.path.normpath( os.path.join(settings.SRCDIR, testname) )
                         # first check if this is a valid name to regenerate
                         if Test.valid_name(testname):
                                 # this is a valid name, let's check if it already exists
                                 found = [test for test in all_tests if canonical_path( test.target() ) == testname]
+                                setup = itertools.product(settings.all_arch if options.arch else [None], settings.all_ast if options.ast else [None])
                                 if not found:
+                                        # it's a new name, create it according to the name and specified architecture
+                                        if options.arch:
+                                                # user specified one or multiple architectures, assume the tests will have architecture specific results
+                                                tests.extend( [Test.new_target(testname, arch) for arch in settings.all_arch] )
+                                        else:
+                                                # user didn't specify an architecture, just create a cross platform test
+                                                tests.append( Test.new_target( testname, None ) )
+                                        # it's a new name, create it according to the name and specified architecture/ast version
+                                        tests.extend( [Test.new_target(testname, arch, ast) for arch, ast in setup] )
                                 elif len(found) == 1 and not found[0].arch:
                                         # we found a single test, the user better be wanting to create a cross platform test
                                         if options.arch:
                                                 print('ERROR: "%s", test has no specified architecture but --arch was specified, ignoring it' % testname, file=sys.stderr)
+                                        elif options.ast:
+                                                print('ERROR: "%s", test has no specified ast version but --ast was specified, ignoring it' % testname, file=sys.stderr)
                                         else:
                                                 tests.append( found[0] )
                                 else:
                                         # this test is already cross platform, just add a test for each platform the user asked
                                         tests.extend( [Test.new_target(testname, arch) for arch in settings.all_arch] )
+                                        tests.extend( [Test.new_target(testname, arch, ast) for arch, ast in setup] )
                                         # print a warning if it users didn't ask for a specific architecture
                                         if not options.arch:
                                                 print('WARNING: "%s", test has architecture specific expected files but --arch was not specified, regenerating only for current host' % testname, file=sys.stderr)
+                                        # print a warning if it users didn't ask for a specific ast version
+                                        if not options.ast:
+                                                print('WARNING: "%s", test has ast version specific expected files but --ast was not specified, regenerating only for current ast' % testname, file=sys.stderr)
                         else :
 …
         # create a parser with the arguments for the tests script
         parser = argparse.ArgumentParser(description='Script which runs cforall tests')
+        parser.add_argument('--ast', help='Test for specific ast', type=comma_separated(str), default=None)
+        parser.add_argument('--arch', help='Test for specific architecture', type=comma_separated(str), default=None)
         parser.add_argument('--debug', help='Run all tests in debug or release', type=comma_separated(yes_no), default='yes')
         parser.add_argument('--install', help='Run all tests based on installed binaries or tree binaries', type=comma_separated(yes_no), default='no')
-        parser.add_argument('--arch', help='Test for specific architecture', type=comma_separated(str), default=None)
         parser.add_argument('--continue', help='When multiple specifications are passed (debug/install/arch), sets whether or not to continue if the last specification failed', type=yes_no, default='yes', dest='continue_')
         parser.add_argument('--timeout', help='Maximum duration in seconds after a single test is considered to have timed out', type=int, default=120)
 …
         except KeyboardInterrupt:
                 return False, ""
         except Exception as ex:
                 print("Unexpected error in worker thread running {}: {}".format(t.target(), ex), file=sys.stderr)
                 sys.stderr.flush()
                 return False, ""
+        # except Exception as ex:
+        #       print("Unexpected error in worker thread running {}: {}".format(t.target(), ex), file=sys.stderr)
+        #       sys.stderr.flush()
+        #       return False, ""
 …
                 # for each build configurations, run the test
                 with Timed() as total_dur:
+                        for arch, debug, install in itertools.product(settings.all_arch, settings.all_debug, settings.all_install):
+                        for ast, arch, debug, install in itertools.product(settings.all_ast, settings.all_arch, settings.all_debug, settings.all_install):
+                                settings.ast     = ast
                                 settings.arch    = arch
                                 settings.debug   = debug
 …
                                 # filter out the tests for a different architecture
                                 # tests are the same across debug/install
+                                local_tests = settings.arch.filter( tests )
+                                local_tests = settings.ast.filter( tests )
+                                local_tests = settings.arch.filter( local_tests )
                                 options.jobs, forceJobs = job_count( options, local_tests )
                                 settings.update_make_cmd(forceJobs, options.jobs)
 …
                                 # print configuration
                                 print('%s %i tests on %i cores (%s:%s)' % (
+                                print('%s %i tests on %i cores (%s:%s - %s)' % (
                                         'Regenerating' if settings.generating else 'Running',
                                         len(local_tests),
                                         options.jobs,
+                                        settings.ast.string,
                                         settings.arch.string,
                                         settings.debug.string
                                 ))
+                                if not local_tests :
+                                        print('WARNING: No tests for this configuration')
+                                        continue
                                 # otherwise run all tests and make sure to return the correct error code

Context Navigation

Legend:

Download in other formats: