Diff [feacef93c7170f91c367bbf622b907c3b2f91777:5407cdc933abc85b76b3bbe365e4c303591d214a] for / – Cforall

Jenkins/FullBuild

-              rfeacef9
+              r5407cdc
                                 parallel (
+                                        gcc_8_x86_old: { trigger_build( 'gcc-8',   'x86', false ) },
+                                        gcc_7_x86_old: { trigger_build( 'gcc-7',   'x86', false ) },
+                                        gcc_6_x86_old: { trigger_build( 'gcc-6',   'x86', false ) },
+                                        gcc_9_x64_old: { trigger_build( 'gcc-9',   'x64', false ) },
+                                        gcc_8_x64_old: { trigger_build( 'gcc-8',   'x64', false ) },
+                                        gcc_7_x64_old: { trigger_build( 'gcc-7',   'x64', false ) },
+                                        gcc_6_x64_old: { trigger_build( 'gcc-6',   'x64', false ) },
+                                        gcc_5_x64_old: { trigger_build( 'gcc-5',   'x64', false ) },
+                                        gcc_8_x86_new: { trigger_build( 'gcc-8',   'x86', true  ) },
+                                        gcc_7_x86_new: { trigger_build( 'gcc-7',   'x86', true  ) },
+                                        gcc_6_x86_new: { trigger_build( 'gcc-6',   'x86', true  ) },
+                                        gcc_9_x64_new: { trigger_build( 'gcc-9',   'x64', true  ) },
+                                        gcc_8_x64_new: { trigger_build( 'gcc-8',   'x64', true  ) },
+                                        gcc_7_x64_new: { trigger_build( 'gcc-7',   'x64', true  ) },
+                                        gcc_6_x64_new: { trigger_build( 'gcc-6',   'x64', true  ) },
+                                        gcc_5_x64_new: { trigger_build( 'gcc-5',   'x64', true  ) },
+                                        clang_x64_new: { trigger_build( 'clang',   'x64', true  ) },
                                         clang_x64_old: { trigger_build( 'clang',   'x64', false ) },
-                                        clang_x64_new: { trigger_build( 'clang',   'x64', true  ) },
+                                )
+                        }
 …
 def trigger_build(String cc, String arch, boolean new_ast) {
+        // Randomly delay the builds by a random amount to avoid hitting the SC server to hard
+        sleep(time: 5 * Math.random(), unit:"MINUTES")
+        // Run the build
+        // Don't propagate, it doesn't play nice with our email setup
         def result = build job: 'Cforall/master',               \
                 parameters: [                                           \

Jenkinsfile

-              rfeacef9
+              r5407cdc
 def test() {
         try {
+                // Print potential limits before testing
+                // in case jenkins messes with them
+                sh 'free -h'
+                sh 'ulimit -a'
                 Tools.BuildStage('Test: short', !Settings.RunAllTests) {
                         dir (BuildDir) {

benchmark/Makefile.am

rfeacef9	r5407cdc
502	502
503	503	compile-io$(EXEEXT):
504		$(CFACOMPILE) -DNO_COMPILED_PRAGMA -fsyntax-only -w $(testdir)/io1.cfa
	504	$(CFACOMPILE) -DNO_COMPILED_PRAGMA -fsyntax-only -w $(testdir)/io/io.cfa
505	505
506	506	compile-monitor$(EXEEXT):

benchmark/basic/ttst_lock.c

-              rfeacef9
+              r5407cdc
 #define CALIGN __attribute__(( aligned (CACHE_ALIGN) ))
 #define CACHE_ALIGN 128
+#define Pause() __asm__ __volatile__ ( "pause" : : : )
+#if defined( __i386 ) || defined( __x86_64 )
+        #define Pause() __asm__ __volatile__ ( "pause" : : : )
+#elif defined( __ARM_ARCH )
+        #define Pause() __asm__ __volatile__ ( "YIELD" : : : )
+#else
+        #error unsupported architecture
+#endif
 typedef uintptr_t TYPE;                                                                 // addressable word-size

benchmark/benchcltr.hfa

-              rfeacef9
+              r5407cdc
         for() {
                 sleep(100`ms);
                 end = getTimeNsec();
+                end = timeHiRes();
                 Duration delta = end - start;
                 /*if(is_tty)*/ {
 …
+}
 #else
 uint64_t getTimeNsec() {
+uint64_t timeHiRes() {
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
 …
         for(;;) {
                 usleep(100000);
                 end = getTimeNsec();
+                end = timeHiRes();
                 uint64_t delta = end - start;
                 /*if(is_tty)*/ {

benchmark/io/http/http_ring.cpp

-              rfeacef9
+              r5407cdc
                 socklen_t *addrlen;
                 int flags;
+                unsigned cnt;
         } acpt;
 …
 thread_local stats_block_t stats;
 stats_block_t global_stats;
+thread_local struct __attribute__((aligned(128))) {
+        size_t to_submit = 0;
+} local;
 // Get an array of current connections
 …
         static void submit(struct io_uring * ring, struct io_uring_sqe * sqe, connection * conn) {
                 (void)ring;
+                local.to_submit++;
                 #ifdef USE_ASYNC
                         io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
 …
                 switch(state) {
                 case ACCEPTING:
                         connection::accept(ring, opt);
+                        // connection::accept(ring, opt);
                         newconn(ring, res);
                         break;
 …
 //=========================================================
+extern "C" {
+        #include <sys/eventfd.h>  // use for termination
+}
 // Main loop of the WebServer
 // Effectively uses one thread_local copy of everything per kernel thread
 …
         struct io_uring * ring = opt.ring;
+        int blockfd = eventfd(0, 0);
+        if (blockfd < 0) {
+                fprintf( stderr, "eventfd create error: (%d) %s\n", (int)errno, strerror(errno) );
+                exit(EXIT_FAILURE);
+        }
+        int ret = io_uring_register_eventfd(ring, blockfd);
+        if (ret < 0) {
+                fprintf( stderr, "io_uring S&W error: (%d) %s\n", (int)-ret, strerror(-ret) );
+                exit(EXIT_FAILURE);
+        }
         // Track the shutdown using a event_fd
         char endfd_buf[8];
 …
         // Accept our first connection
         // May not take effect until io_uring_submit_and_wait
+        connection::accept(ring, opt);
+        for(unsigned i = 0; i < opt.acpt.cnt; i++) {
+                connection::accept(ring, opt);
+        }
         int reset = 1;       // Counter to print stats once in a while
 …
         while(!done) {
                 // Submit all the answers we have and wait for responses
+                int ret = io_uring_submit_and_wait(ring, 1);
+                int ret = io_uring_submit(ring);
+                local.to_submit = 0;
                 // check errors
 …
                 sqes += ret;
                 call++;
+                eventfd_t val;
+                ret = eventfd_read(blockfd, &val);
+                // check errors
+                if (ret < 0) {
+                        fprintf( stderr, "eventfd read error: (%d) %s\n", (int)errno, strerror(errno) );
+                        exit(EXIT_FAILURE);
+                }
                 struct io_uring_cqe *cqe;
 …
                                 break;
+                        }
+                        if(local.to_submit > 30) break;
                         auto req = (class connection *)cqe->user_data;
 …
         #include <pthread.h>      // for pthreads
         #include <signal.h>       // for signal(SIGPIPE, SIG_IGN);
-        #include <sys/eventfd.h>  // use for termination
         #include <sys/socket.h>   // for sockets in general
         #include <netinet/in.h>   // for sockaddr_in, AF_INET
 …
         unsigned entries = 256;     // number of entries per ring/kernel thread
         unsigned backlog = 262144;  // backlog argument to listen
+        unsigned preaccept = 1;     // start by accepting X per threads
         bool attach = false;        // Whether or not to attach all the rings
         bool sqpoll = false;        // Whether or not to use SQ Polling
 …
         // Arguments Parsing
         int c;
         while ((c = getopt (argc, argv, "t:p:e:b:aS")) != -1) {
+        while ((c = getopt (argc, argv, "t:p:e:b:c:aS")) != -1) {
                 switch (c)
+                {
 …
                 case 'b':
                         backlog = atoi(optarg);
+                        break;
+                case 'c':
+                        preaccept = atoi(optarg);
                         break;
                 case 'a':
 …
                 thrd_opts[i].acpt.addrlen = (socklen_t*)&addrlen;
                 thrd_opts[i].acpt.flags   = 0;
+                thrd_opts[i].acpt.cnt     = preaccept;
                 thrd_opts[i].endfd        = efd;
                 thrd_opts[i].ring         = &thrd_rings[i].storage;

benchmark/io/http/main.cfa

-              rfeacef9
+              r5407cdc
 //=============================================================================================
-// Globals
-//=============================================================================================
-struct ServerProc {
-        processor self;
-};
-void ?{}( ServerProc & this ) {
-        /* paranoid */ assert( options.clopts.instance != 0p );
-        (this.self){ "Benchmark Processor", *options.clopts.instance };
-        #if !defined(__CFA_NO_STATISTICS__)
-                if( options.clopts.procstats ) {
-                        print_stats_at_exit( this.self, options.clopts.instance->print_stats );
+                }
-                if( options.clopts.viewhalts ) {
-                        print_halts( this.self );
+                }
-        #endif
+}
-extern void init_protocol(void);
-extern void deinit_protocol(void);
-//=============================================================================================
 // Stats Printer
 //============================================================================================='
 …
 thread StatsPrinter {};
+void ?{}( StatsPrinter & this ) {
+        ((thread&)this){ "Stats Printer Thread" };
+}
+void ?{}( StatsPrinter & this, cluster & cl ) {
+        ((thread&)this){ "Stats Printer Thread", cl };
+}
+void ^?{}( StatsPrinter & mutex this ) {}
 void main(StatsPrinter & this) {
 …
                 sleep(10`s);
+                print_stats_now( *options.clopts.instance, CFA_STATS_READY_Q | CFA_STATS_IO );
+        }
+}
+                print_stats_now( *active_cluster(), CFA_STATS_READY_Q | CFA_STATS_IO );
+        }
+}
+//=============================================================================================
+// Globals
+//=============================================================================================
+struct ServerCluster {
+        cluster self;
+        processor    * procs;
+        // io_context   * ctxs;
+        StatsPrinter * prnt;
+};
+void ?{}( ServerCluster & this ) {
+        (this.self){ "Server Cluster", options.clopts.params };
+        this.procs = alloc(options.clopts.nprocs);
+        for(i; options.clopts.nprocs) {
+                (this.procs[i]){ "Benchmark Processor", this.self };
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if( options.clopts.procstats ) {
+                                print_stats_at_exit( *this.procs, this.self.print_stats );
+                        }
+                        if( options.clopts.viewhalts ) {
+                                print_halts( *this.procs );
+                        }
+                #endif
+        }
+        if(options.stats) {
+                this.prnt = alloc();
+                (*this.prnt){ this.self };
+        } else {
+                this.prnt = 0p;
+        }
+        #if !defined(__CFA_NO_STATISTICS__)
+                print_stats_at_exit( this.self, CFA_STATS_READY_Q | CFA_STATS_IO );
+        #endif
+        options.clopts.instance[options.clopts.cltr_cnt] = &this.self;
+        options.clopts.cltr_cnt++;
+}
+void ^?{}( ServerCluster & this ) {
+        delete(this.prnt);
+        for(i; options.clopts.nprocs) {
+                ^(this.procs[i]){};
+        }
+        free(this.procs);
+        ^(this.self){};
+}
+extern void init_protocol(void);
+extern void deinit_protocol(void);
 //=============================================================================================
 …
         // Run Server Cluster
+        {
-                cluster cl = { "Server Cluster", options.clopts.params };
-                #if !defined(__CFA_NO_STATISTICS__)
-                        print_stats_at_exit( cl, CFA_STATS_READY_Q | CFA_STATS_IO );
-                #endif
-                options.clopts.instance = &cl;
                 int pipe_cnt = options.clopts.nworkers * 2;
                 int pipe_off;
 …
+                }
                 if(options.file_cache.path && options.file_cache.fixed_fds) {
                         register_fixed_files(cl, fds, pipe_off);
+                }
+                // if(options.file_cache.path && options.file_cache.fixed_fds) {
+                //      register_fixed_files(cl, fds, pipe_off);
+                // }
+                {
+                        ServerProc procs[options.clopts.nprocs];
+                        StatsPrinter printer;
+                        ServerCluster cl[options.clopts.nclusters];
                         init_protocol();
 …
                                         unpark( workers[i] );
+                                }
+                                sout | options.clopts.nworkers | "workers started on" | options.clopts.nprocs | "processors";
+                                sout | options.clopts.nworkers | "workers started on" | options.clopts.nprocs | "processors /" | options.clopts.nclusters | "clusters";
+                                for(i; options.clopts.nclusters) {
+                                        sout | options.clopts.thrd_cnt[i] | nonl;
+                                }
+                                sout | nl;
+                                {
                                         char buffer[128];
+                                        while(int ret = cfa_read(0, buffer, 128, 0, -1`s, 0p, 0p); ret != 0) {
+                                        for() {
+                                                int ret = cfa_read(0, buffer, 128, 0);
+                                                if(ret == 0) break;
                                                 if(ret < 0) abort( "main read error: (%d) %s\n", (int)errno, strerror(errno) );
+                                                sout | "User wrote '" | "" | nonl;
+                                                write(sout, buffer, ret - 1);
+                                                sout | "'";
+                                        }
 …
                                 for(i; options.clopts.nworkers) {
                                         workers[i].done = true;
-                                        cancel(workers[i].cancel);
+                                }
                                 sout | "done";
 …
                         sout | "done";
                         sout | "Stopping processors..." | nonl; flush( sout );
+                        sout | "Stopping processors/clusters..." | nonl; flush( sout );
+                }
                 sout | "done";

benchmark/io/http/options.cfa

-              rfeacef9
+              r5407cdc
 #include <kernel.hfa>
 #include <parseargs.hfa>
+#include <stdlib.hfa>
 #include <stdlib.h>
 …
 Options options @= {
         false, // log
+        false, // stats
         { // file_cache
 …
         { // cluster
+,     // nclusters;
 ,     // nprocs;
 ,     // nworkers;
 …
 void parse_options( int argc, char * argv[] ) {
+        bool subthrd = false;
+        bool eagrsub = false;
+        bool fixedfd = false;
+        bool sqkpoll = false;
+        bool iokpoll = false;
+        unsigned sublen = 16;
+        // bool fixedfd = false;
+        // bool sqkpoll = false;
+        // bool iokpoll = false;
         unsigned nentries = 16;
+        bool isolate = false;
 …
                 { 'c', "cpus",           "Number of processors to use", options.clopts.nprocs},
                 { 't', "threads",        "Number of worker threads to use", options.clopts.nworkers},
+                {'\0', "isolate",        "Create one cluster per processor", isolate, parse_settrue},
                 {'\0', "log",            "Enable logs", options.log, parse_settrue},
+                {'\0', "stats",          "Enable statistics", options.stats, parse_settrue},
                 {'\0', "accept-backlog", "Maximum number of pending accepts", options.socket.backlog},
                 {'\0', "request_len",    "Maximum number of bytes in the http request, requests with more data will be answered with Http Code 414", options.socket.buflen},
 …
                 {'\0', "cache-size",     "Size of the cache to use, if set to small, will uses closes power of 2", options.file_cache.size },
                 {'\0', "list-files",     "List the files in the specified path and exit", options.file_cache.list, parse_settrue },
+                { 's', "submitthread",   "If set, cluster uses polling thread to submit I/O", subthrd, parse_settrue },
+                { 'e', "eagersubmit",    "If set, cluster submits I/O eagerly but still aggregates submits", eagrsub, parse_settrue},
+                { 'f', "fixed-fds",      "If set, files are open eagerly and pre-registered with the cluster", fixedfd, parse_settrue},
+                { 'k', "kpollsubmit",    "If set, cluster uses IORING_SETUP_SQPOLL, implies -f", sqkpoll, parse_settrue },
+                { 'i', "kpollcomplete",  "If set, cluster uses IORING_SETUP_IOPOLL", iokpoll, parse_settrue },
+                {'\0', "submitlength",   "Max number of submitions that can be submitted together", sublen },
+                {'\0', "numentries",     "Number of I/O entries", nentries },
+                // { 'f', "fixed-fds",      "If set, files are open eagerly and pre-registered with the cluster", fixedfd, parse_settrue},
+                // { 'k', "kpollsubmit",    "If set, cluster uses IORING_SETUP_SQPOLL, implies -f", sqkpoll, parse_settrue },
+                // { 'i', "kpollcomplete",  "If set, cluster uses IORING_SETUP_IOPOLL", iokpoll, parse_settrue },
+                {'e', "numentries",     "Number of I/O entries", nentries },
         };
 …
                 nentries = v;
+        }
+        if(isolate) {
+                options.clopts.nclusters = options.clopts.nprocs;
+                options.clopts.nprocs = 1;
+        }
         options.clopts.params.num_entries = nentries;
+        options.clopts.params.poller_submits = subthrd;
+        options.clopts.params.eager_submits  = eagrsub;
+        if( fixedfd ) {
+                options.file_cache.fixed_fds = true;
+        options.clopts.instance = alloc(options.clopts.nclusters);
+        options.clopts.thrd_cnt = alloc(options.clopts.nclusters);
+        options.clopts.cltr_cnt = 0;
+        for(i; options.clopts.nclusters) {
+                options.clopts.thrd_cnt[i] = 0;
+        }
-        if( sqkpoll ) {
-                options.clopts.params.poll_submit = true;
-                options.file_cache.fixed_fds = true;
+        }
+        if( iokpoll ) {
+                options.clopts.params.poll_complete = true;
+                options.file_cache.open_flags |= O_DIRECT;
+        }
+        // if( fixedfd ) {
+        //      options.file_cache.fixed_fds = true;
+        // }
+        options.clopts.params.num_ready = sublen;
+        // if( sqkpoll ) {
+        //      options.file_cache.fixed_fds = true;
+        // }
+        // if( iokpoll ) {
+        //      options.file_cache.open_flags |= O_DIRECT;
+        // }
         if( left[0] == 0p ) { return; }

benchmark/io/http/options.hfa

-              rfeacef9
+              r5407cdc
 struct Options {
         bool log;
+        bool stats;
         struct {
 …
         struct {
+                int nclusters;
                 int nprocs;
                 int nworkers;
 …
                 bool procstats;
                 bool viewhalts;
+                cluster * instance;
+                cluster ** instance;
+                size_t   * thrd_cnt;
+                size_t     cltr_cnt;
         } clopts;
 };

benchmark/io/http/protocol.cfa

-              rfeacef9
+              r5407cdc
         #include <fcntl.h>
+}
+#define xstr(s) str(s)
+#define str(s) #s
 #include <fstream.hfa>
 …
 #include "options.hfa"
+const char * volatile date = 0p;
+const char * http_msgs[] = {
+        "HTTP/1.1 200 OK\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: %zu \n\n",
+        "HTTP/1.1 400 Bad Request\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 404 Not Found\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 405 Method Not Allowed\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 408 Request Timeout\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 413 Payload Too Large\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 414 URI Too Long\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+};
+#define PLAINTEXT_1WRITE
+#define PLAINTEXT_MEMCPY
+#define PLAINTEXT_NOCOPY
+struct https_msg_str {
+        char msg[512];
+        size_t len;
+};
+const https_msg_str * volatile http_msgs[KNOWN_CODES] = { 0 };
 _Static_assert( KNOWN_CODES == (sizeof(http_msgs ) / sizeof(http_msgs [0])));
+const int http_codes[] = {
+const int http_codes[KNOWN_CODES] = {
+,
 ,
 ,
 …
         while(len > 0) {
                 // Call write
+                int ret = cfa_write(fd, it, len, 0, -1`s, 0p, 0p);
+                // int ret = write(fd, it, len);
+                int ret = cfa_send(fd, it, len, 0, CFA_IO_LAZY);
                 if( ret < 0 ) {
                         if( errno == ECONNRESET || errno == EPIPE ) return -ECONNRESET;
 …
         /* paranoid */ assert( code < KNOWN_CODES && code != OK200 );
         int idx = (int)code;
         return answer( fd, http_msgs[idx], strlen( http_msgs[idx] ) );
+        return answer( fd, http_msgs[idx]->msg, http_msgs[idx]->len );
+}
 int answer_header( int fd, size_t size ) {
+        const char * fmt = http_msgs[OK200];
+        int len = 200;
+        char buffer[len];
+        len = snprintf(buffer, len, fmt, date, size);
+        char buffer[512];
+        char * it = buffer;
+        memcpy(it, http_msgs[OK200]->msg, http_msgs[OK200]->len);
+        it += http_msgs[OK200]->len;
+        int len = http_msgs[OK200]->len;
+        len += snprintf(it, 512 - len, "%d \n\n", size);
         return answer( fd, buffer, len );
+}
+int answer_plain( int fd, char buffer[], size_t size ) {
+        int ret = answer_header(fd, size);
+#if defined(PLAINTEXT_NOCOPY)
+int answer_plaintext( int fd ) {
+        return answer(fd, http_msgs[OK200_PlainText]->msg, http_msgs[OK200_PlainText]->len); // +1 cause snprintf doesn't count nullterminator
+}
+#elif defined(PLAINTEXT_MEMCPY)
+#define TEXTSIZE 15
+int answer_plaintext( int fd ) {
+        char text[] = "Hello, World!\n\n";
+        char ts[] = xstr(TEXTSIZE) " \n\n";
+        _Static_assert(sizeof(text) - 1 == TEXTSIZE);
+        char buffer[512 + TEXTSIZE];
+        char * it = buffer;
+        memcpy(it, http_msgs[OK200]->msg, http_msgs[OK200]->len);
+        it += http_msgs[OK200]->len;
+        int len = http_msgs[OK200]->len;
+        memcpy(it, ts, sizeof(ts) - 1);
+        it += sizeof(ts) - 1;
+        len += sizeof(ts) - 1;
+        memcpy(it, text, TEXTSIZE);
+        return answer(fd, buffer, len + TEXTSIZE);
+}
+#elif defined(PLAINTEXT_1WRITE)
+int answer_plaintext( int fd ) {
+        char text[] = "Hello, World!\n\n";
+        char buffer[512 + sizeof(text)];
+        char * it = buffer;
+        memcpy(it, http_msgs[OK200]->msg, http_msgs[OK200]->len);
+        it += http_msgs[OK200]->len;
+        int len = http_msgs[OK200]->len;
+        int r = snprintf(it, 512 - len, "%d \n\n", sizeof(text));
+        it += r;
+        len += r;
+        memcpy(it, text, sizeof(text));
+        return answer(fd, buffer, len + sizeof(text));
+}
+#else
+int answer_plaintext( int fd ) {
+        char text[] = "Hello, World!\n\n";
+        int ret = answer_header(fd, sizeof(text));
         if( ret < 0 ) return ret;
+        return answer(fd, buffer, size);
+}
+        return answer(fd, text, sizeof(text));
+}
+#endif
 int answer_empty( int fd ) {
 …
 [HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len, io_cancellation * cancel) {
+[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len) {
         char * it = buffer;
         size_t count = len - 1;
 …
         READ:
         for() {
                 int ret = cfa_read(fd, (void*)it, count, 0, -1`s, cancel, 0p);
+                int ret = cfa_recv(fd, (void*)it, count, 0, CFA_IO_LAZY);
                 // int ret = read(fd, (void*)it, count);
                 if(ret == 0 ) return [OK200, true, 0, 0];
 …
         ssize_t ret;
         SPLICE1: while(count > 0) {
+                ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, sflags, 0, -1`s, 0p, 0p);
+                // ret = splice(ans_fd, &offset, pipe[1], 0p, count, sflags);
+                ret = cfa_splice(ans_fd, &offset, pipe[1], 0p, count, sflags, CFA_IO_LAZY);
                 if( ret < 0 ) {
                         if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE1;
 …
                 size_t in_pipe = ret;
                 SPLICE2: while(in_pipe > 0) {
+                        ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, sflags, 0, -1`s, 0p, 0p);
+                        // ret = splice(pipe[0], 0p, fd, 0p, in_pipe, sflags);
+                        ret = cfa_splice(pipe[0], 0p, fd, 0p, in_pipe, sflags, CFA_IO_LAZY);
                         if( ret < 0 ) {
                                 if( errno != EAGAIN && errno != EWOULDBLOCK) continue SPLICE2;
 …
 #include <thread.hfa>
+const char * original_http_msgs[] = {
+        "HTTP/1.1 200 OK\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: ",
+        "HTTP/1.1 200 OK\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 15\n\nHello, World!\n\n",
+        "HTTP/1.1 400 Bad Request\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 404 Not Found\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 405 Method Not Allowed\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 408 Request Timeout\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 413 Payload Too Large\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 414 URI Too Long\nServer: HttoForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+};
 struct date_buffer {
         char buff[100];
+        https_msg_str strs[KNOWN_CODES];
 };
 …
 void ?{}( DateFormater & this ) {
         ((thread&)this){ "Server Date Thread", *options.clopts.instance };
+        ((thread&)this){ "Server Date Thread", *options.clopts.instance[0] };
         this.idx = 0;
         memset( this.buffers[0].buff, 0, sizeof(this.buffers[0]) );
         memset( this.buffers[1].buff, 0, sizeof(this.buffers[1]) );
+        memset( &this.buffers[0], 0, sizeof(this.buffers[0]) );
+        memset( &this.buffers[1], 0, sizeof(this.buffers[1]) );
+}
 …
                 or else {}
+                Time now = getTimeNsec();
+                strftime( this.buffers[this.idx].buff, 100, "%a, %d %b %Y %H:%M:%S %Z", now );
+                char * next = this.buffers[this.idx].buff;
+                __atomic_exchange_n((char * volatile *)&date, next, __ATOMIC_SEQ_CST);
+                char buff[100];
+                Time now = timeHiRes();
+                strftime( buff, 100, "%a, %d %b %Y %H:%M:%S %Z", now );
+                sout | "Updated date to '" | buff | "'";
+                for(i; KNOWN_CODES) {
+                        size_t len = snprintf( this.buffers[this.idx].strs[i].msg, 512, original_http_msgs[i], buff );
+                        this.buffers[this.idx].strs[i].len = len;
+                }
+                for(i; KNOWN_CODES) {
+                        https_msg_str * next = &this.buffers[this.idx].strs[i];
+                        __atomic_exchange_n((https_msg_str * volatile *)&http_msgs[i], next, __ATOMIC_SEQ_CST);
+                }
                 this.idx = (this.idx + 1) % 2;
+                sout | "Date thread sleeping";
                 sleep(1`s);

benchmark/io/http/protocol.hfa

-              rfeacef9
+              r5407cdc
 #pragma once
-struct io_cancellation;
 enum HttpCode {
         OK200 = 0,
+        OK200_PlainText,
         E400,
         E404,
 …
 int answer_error( int fd, HttpCode code );
 int answer_header( int fd, size_t size );
 int answer_plain( int fd, char buffer [], size_t size );
+int answer_plaintext( int fd );
 int answer_empty( int fd );
 [HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len, io_cancellation *);
+[HttpCode code, bool closed, * const char file, size_t len] http_read(int fd, []char buffer, size_t len);
 int sendfile( int pipe[2], int fd, int ans_fd, size_t count );

benchmark/io/http/worker.cfa

-              rfeacef9
+              r5407cdc
 //=============================================================================================
 void ?{}( Worker & this ) {
+        ((thread&)this){ "Server Worker Thread", *options.clopts.instance };
+        size_t cli = rand() % options.clopts.cltr_cnt;
+        ((thread&)this){ "Server Worker Thread", *options.clopts.instance[cli], 512000 };
+        options.clopts.thrd_cnt[cli]++;
         this.pipe[0] = -1;
         this.pipe[1] = -1;
 …
         for() {
                 if( options.log ) sout | "=== Accepting connection ===";
+                int fd = cfa_accept4( this.[sockfd, addr, addrlen, flags], 0, -1`s, &this.cancel, 0p );
+                // int fd = accept4( this.[sockfd, addr, addrlen, flags] );
+                int fd = cfa_accept4( this.[sockfd, addr, addrlen, flags], CFA_IO_LAZY );
                 if(fd < 0) {
                         if( errno == ECONNABORTED ) break;
 …
                         abort( "accept error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                if(this.done) break;
                 if( options.log ) sout | "=== New connection" | fd | "" | ", waiting for requests ===";
 …
                         char buffer[len];
                         if( options.log ) sout | "=== Reading request ===";
                         [code, closed, file, name_size] = http_read(fd, buffer, len, &this.cancel);
+                        [code, closed, file, name_size] = http_read(fd, buffer, len);
                         // if we are done, break out of the loop
 …
                                 if( options.log ) sout | "=== Request for /plaintext ===";
+                                char text[] = "Hello, World!\n";
+                                // Send the header
+                                int ret = answer_plain(fd, text, sizeof(text));
+                                int ret = answer_plaintext(fd);
                                 if( ret == -ECONNRESET ) break REQUEST;

benchmark/io/http/worker.hfa

rfeacef9	r5407cdc
17	17	socklen_t * addrlen;
18	18	int flags;
19		~~io_cancellation cancel;~~
20	19	volatile bool done;
21	20	};

benchmark/io/readv-posix.c

-              rfeacef9
+              r5407cdc
                                 printf("Starting\n");
                                 bool is_tty = isatty(STDOUT_FILENO);
                                 start = getTimeNsec();
+                                start = timeHiRes();
                                 run = true;
 …
                                 run = false;
                                 end = getTimeNsec();
+                                end = timeHiRes();
                                 printf("\nDone\n");

benchmark/io/readv.cfa

-              rfeacef9
+              r5407cdc
                                 printf("Starting\n");
                                 bool is_tty = isatty(STDOUT_FILENO);
                                 start = getTimeNsec();
+                                start = timeHiRes();
                                 run = true;
 …
                                 run = false;
                                 end = getTimeNsec();
+                                end = timeHiRes();
                                 printf("\nDone\n");
+                        }

benchmark/readyQ/cycle.cc

-              rfeacef9
+              r5407cdc
                         bool is_tty = isatty(STDOUT_FILENO);
                         start = getTimeNsec();
+                        start = timeHiRes();
                         for(int i = 0; i < nthreads; i++) {
 …
                         stop = true;
                         end = getTimeNsec();
+                        end = timeHiRes();
                         printf("\nDone\n");

benchmark/readyQ/cycle.cfa

-              rfeacef9
+              r5407cdc
                         bool is_tty = isatty(STDOUT_FILENO);
                         start = getTimeNsec();
+                        start = timeHiRes();
                         for(i; nthreads) {
 …
                         stop = true;
                         end = getTimeNsec();
+                        end = timeHiRes();
                         printf("\nDone\n");

benchmark/readyQ/cycle.cpp

-              rfeacef9
+              r5407cdc
 #include <libfibre/fibre.h>
-class __attribute__((aligned(128))) bench_sem {
-        Fibre * volatile ptr = nullptr;
-public:
-        inline bool wait() {
-                static Fibre * const ready  = reinterpret_cast<Fibre * const>(1ull);
-                for(;;) {
-                        Fibre * expected = this->ptr;
-                        if(expected == ready) {
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        return false;
+                                }
+                        }
-                        else {
-                                /* paranoid */ assert( expected == nullptr );
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, fibre_self(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        fibre_park();
-                                        return true;
+                                }
+                        }
+                }
+        }
-        inline bool post() {
-                static Fibre * const ready  = reinterpret_cast<Fibre * const>(1ull);
-                for(;;) {
-                        Fibre * expected = this->ptr;
-                        if(expected == ready) return false;
-                        if(expected == nullptr) {
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, ready, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        return false;
+                                }
+                        }
-                        else {
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        fibre_unpark( expected );
-                                        return true;
+                                }
+                        }
+                }
+        }
-};
 struct Partner {
         unsigned long long count  = 0;
 …
                         bool is_tty = isatty(STDOUT_FILENO);
                         start = getTimeNsec();
+                        start = timeHiRes();
                         for(int i = 0; i < nthreads; i++) {
 …
                         stop = true;
                         end = getTimeNsec();
+                        end = timeHiRes();
                         printf("\nDone\n");

benchmark/readyQ/locality.cfa

-              rfeacef9
+              r5407cdc
                         bool is_tty = isatty(STDOUT_FILENO);
                         start = getTimeNsec();
+                        start = timeHiRes();
                         for(i; nthreads) {
 …
                         stop = true;
                         end = getTimeNsec();
+                        end = timeHiRes();
                         printf("\nDone\n");

benchmark/readyQ/locality.cpp

-              rfeacef9
+              r5407cdc
         uint64_t dmigs = 0;
         uint64_t gmigs = 0;
-};
-class __attribute__((aligned(128))) bench_sem {
-        Fibre * volatile ptr = nullptr;
-public:
-        inline bool wait() {
-                static Fibre * const ready  = reinterpret_cast<Fibre * const>(1ull);
-                for(;;) {
-                        Fibre * expected = this->ptr;
-                        if(expected == ready) {
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        return false;
+                                }
+                        }
-                        else {
-                                /* paranoid */ assert( expected == nullptr );
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, fibre_self(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        fibre_park();
-                                        return true;
+                                }
+                        }
+                }
+        }
-        inline bool post() {
-                static Fibre * const ready  = reinterpret_cast<Fibre * const>(1ull);
-                for(;;) {
-                        Fibre * expected = this->ptr;
-                        if(expected == ready) return false;
-                        if(expected == nullptr) {
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, ready, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        return false;
+                                }
+                        }
-                        else {
-                                if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-                                        fibre_unpark( expected );
-                                        return true;
+                                }
+                        }
+                }
+        }
 };
 …
                         bool is_tty = isatty(STDOUT_FILENO);
                         start = getTimeNsec();
+                        start = timeHiRes();
                         for(size_t i = 0; i < nthreads; i++) {
 …
                         stop = true;
                         end = getTimeNsec();
+                        end = timeHiRes();
                         printf("\nDone\n");

benchmark/readyQ/rq_bench.hfa

-              rfeacef9
+              r5407cdc
 #include <stdio.h>
 #include <stdlib.hfa>
+#include <stats.hfa>
 #include <thread.hfa>
 #include <time.hfa>
 …
                 (*p){ "Benchmark Processor", this.cl };
+        }
+        #if !defined(__CFA_NO_STATISTICS__)
+                print_stats_at_exit( this.cl, CFA_STATS_READY_Q );
+        #endif
+}
 …
         for() {
                 sleep(100`ms);
                 Time end = getTimeNsec();
+                Time end = timeHiRes();
                 Duration delta = end - start;
                 if(is_tty) {

benchmark/readyQ/rq_bench.hpp

-              rfeacef9
+              r5407cdc
 #include <time.h>                                                                               // timespec
 #include <sys/time.h>                                                                   // timeval
+typedef __uint128_t __lehmer64_state_t;
+static inline uint64_t __lehmer64( __lehmer64_state_t & state ) {
+        state *= 0xda942042e4dd58b5;
+        return state >> 64;
+}
 enum { TIMEGRAN = 1000000000LL };                                       // nanosecond granularity, except for timeval
 …
+        }
 uint64_t getTimeNsec() {
+uint64_t timeHiRes() {
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
 …
         for(;;) {
                 Sleeper::usleep(100000);
                 uint64_t end = getTimeNsec();
+                uint64_t end = timeHiRes();
                 uint64_t delta = end - start;
                 if(is_tty) {
 …
+        }
+}
+class Fibre;
+int fibre_park();
+int fibre_unpark( Fibre * );
+Fibre * fibre_self();
+class __attribute__((aligned(128))) bench_sem {
+        Fibre * volatile ptr = nullptr;
+public:
+        inline bool wait() {
+                static Fibre * const ready  = reinterpret_cast<Fibre *>(1ull);
+                for(;;) {
+                        Fibre * expected = this->ptr;
+                        if(expected == ready) {
+                                if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                        return false;
+                                }
+                        }
+                        else {
+                                /* paranoid */ assert( expected == nullptr );
+                                if(__atomic_compare_exchange_n(&this->ptr, &expected, fibre_self(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                        fibre_park();
+                                        return true;
+                                }
+                        }
+                }
+        }
+        inline bool post() {
+                static Fibre * const ready  = reinterpret_cast<Fibre *>(1ull);
+                for(;;) {
+                        Fibre * expected = this->ptr;
+                        if(expected == ready) return false;
+                        if(expected == nullptr) {
+                                if(__atomic_compare_exchange_n(&this->ptr, &expected, ready, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                        return false;
+                                }
+                        }
+                        else {
+                                if(__atomic_compare_exchange_n(&this->ptr, &expected, nullptr, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                        fibre_unpark( expected );
+                                        return true;
+                                }
+                        }
+                }
+        }
+};
 // ==========================================================================================
 …
                 this->help       = help;
                 this->variable   = reinterpret_cast<void*>(&variable);
+                this->parse_fun  = reinterpret_cast<bool (*)(const char *, void * )>(static_cast<bool (*)(const char *, T & )>(parse));
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wcast-function-type"
+                                this->parse_fun  = reinterpret_cast<bool (*)(const char *, void * )>(static_cast<bool (*)(const char *, T & )>(parse));
+                #pragma GCC diagnostic pop
+        }
 …
                 this->help       = help;
                 this->variable   = reinterpret_cast<void*>(&variable);
+                this->parse_fun  = reinterpret_cast<bool (*)(const char *, void * )>(parse);
+                #pragma GCC diagnostic push
+                #pragma GCC diagnostic ignored "-Wcast-function-type"
+                        this->parse_fun  = reinterpret_cast<bool (*)(const char *, void * )>(parse);
+                #pragma GCC diagnostic pop
+        }
 };

benchmark/readyQ/yield.cfa

-              rfeacef9
+              r5407cdc
                                 bool is_tty = isatty(STDOUT_FILENO);
                                 start = getTimeNsec();
+                                start = timeHiRes();
                                 run = true;
 …
                                 run = false;
                                 end = getTimeNsec();
+                                end = timeHiRes();
                                 printf("\nDone\n");
+                        }

doc/LaTeXmacros/lstlang.sty

-              rfeacef9
+              r5407cdc
 %% Created On       : Sat May 13 16:34:42 2017
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Wed Sep 23 22:40:04 2020
 %% Update Count     : 24
+%% Last Modified On : Wed Feb 17 09:21:15 2021
+%% Update Count     : 27
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
         morekeywords={
                 _Alignas, _Alignof, __alignof, __alignof__, asm, __asm, __asm__, __attribute, __attribute__,
                 auto, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
                 coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally,
+                auto, basetypeof, _Bool, catch, catchResume, choose, _Complex, __complex, __complex__, __const, __const__,
+                coroutine, disable, dtype, enable, exception, __extension__, fallthrough, fallthru, finally, fixup,
                 __float80, float80, __float128, float128, forall, ftype, generator, _Generic, _Imaginary, __imag, __imag__,
                 inline, __inline, __inline__, __int128, int128, __label__, monitor, mutex, _Noreturn, one_t, or,
                 otype, restrict, __restrict, __restrict__, __signed, __signed__, _Static_assert, suspend, thread,
                 _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
+                otype, restrict, __restrict, __restrict__, recover, report, __signed, __signed__, _Static_assert, suspend,
+                thread, _Thread_local, throw, throwResume, timeout, trait, try, ttype, typeof, __typeof, __typeof__,
                 virtual, __volatile, __volatile__, waitfor, when, with, zero_t,
     },

doc/bibliography/pl.bib

-              rfeacef9
+              r5407cdc
+}
 @article{Delisle20,
+@article{Delisle21,
     keywords    = {concurrency, Cforall},
     contributer = {pabuhr@plg},
     author      = {Thierry Delisle and Peter A. Buhr},
     title       = {Advanced Control-flow and Concurrency in \textsf{C}$\mathbf{\forall}$},
-    year        = 2020,
     journal     = spe,
+    pages       = {1-38},
+    note        = {\href{https://doi-org.proxy.lib.uwaterloo.ca/10.1002/spe.2925}{https://\-doi-org.proxy.lib.uwaterloo.ca/\-10.1002/\-spe.2925}},
+    note        = {},
+    month       = may,
+    year        = 2021,
+    volume      = 51,
+    number      = 5,
+    pages       = {1005-1042},
+    note        = {\href{https://onlinelibrary.wiley.com/doi/10.1002/spe.2925}{https://\-onlinelibrary.wiley.com/\-doi/\-10.1002/\-spe.2925}},
+}
 …
     month       = jan,
     address     = {Waterloo, Ontario, Canada, N2L 3G1},
     note        = {\textsf{http://uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}},
+    note        = {\href{http://uwspace.uwaterloo.ca/bitstream/10012/3501/1/Thesis.pdf}{http://\-uwspace.uwaterloo.ca/\-bitstream/\-10012/\-3501/\-1/\-Thesis.pdf}},
+}

doc/theses/andrew_beach_MMath/Makefile

-              rfeacef9
+              r5407cdc
 BUILD=out
 TEXSRC=$(wildcard *.tex)
+FIGSRC=$(wildcard *.fig)
 BIBSRC=$(wildcard *.bib)
 STYSRC=$(wildcard *.sty)
 …
 BASE= ${DOC:%.pdf=%}
+RAWSRC=${TEXSRC} ${BIBSRC} ${STYSRC} ${CLSSRC}
+FIGTEX=${FIGSRC:%.fig=${BUILD}/%.tex}
 ### Special Rules:
 …
 ### Commands:
 LATEX=TEXINPUTS=${TEXLIB} pdflatex -halt-on-error -output-directory=${BUILD}
+LATEX=TEXINPUTS=${TEXLIB} latex -halt-on-error -output-directory=${BUILD}
 BIBTEX=BIBINPUTS=${BIBLIB} bibtex
 GLOSSARY=INDEXSTYLE=${BUILD} makeglossaries-lite
 …
 all: ${DOC}
+${BUILD}/${DOC}: ${TEXSRC} ${BIBSRC} ${STYSRC} ${CLSSRC} Makefile | ${BUILD}
+# The main rule, it does all the tex/latex processing.
+${BUILD}/${BASE}.dvi: ${RAWSRC} ${FIGTEX} Makefile | ${BUILD}
         ${LATEX} ${BASE}
         ${BIBTEX} ${BUILD}/${BASE}
 …
         ${LATEX} ${BASE}
+${DOC}: ${BUILD}/${DOC}
+        cp $< $@
+# Convert xfig output to tex. (Generates \special declarations.)
+${FIGTEX}: ${BUILD}/%.tex: %.fig | ${BUILD}
+        fig2dev -L eepic $< > $@
+# Step through dvi & postscript to handle xfig specials.
+%.pdf : ${BUILD}/%.dvi
+        dvipdf $^ $@
 ${BUILD}:

doc/theses/andrew_beach_MMath/existing.tex

-              rfeacef9
+              r5407cdc
 \section{Overloading and \lstinline{extern}}
 \CFA has extensive overloading, allowing multiple definitions of the same name
 to be defined.~\cite{Moss18}
+to be defined~\cite{Moss18}.
 \begin{cfa}
 char i; int i; double i;                        $\C[3.75in]{// variable overload}$
 …
 pointers using the ampersand (@&@) instead of the pointer asterisk (@*@). \CFA
 references may also be mutable or non-mutable. If mutable, a reference variable
 may be assigned to using the address-of operator (@&@), which converts the
+may be assigned using the address-of operator (@&@), which converts the
 reference to a pointer.
 \begin{cfa}
 …
 \section{Constructors and Destructors}
 Both constructors and destructors are operators, which means they are just
+Both constructors and destructors are operators, which means they are
 functions with special operator names rather than type names in \Cpp. The
 special operator names may be used to call the functions explicitly (not
 …
 In general, operator names in \CFA are constructed by bracketing an operator
 token with @?@, which indicates where the arguments. For example, infixed
+token with @?@, which indicates the position of the arguments. For example, infixed
 multiplication is @?*?@ while prefix dereference is @*?@. This syntax make it
 easy to tell the difference between prefix operations (such as @++?@) and
 …
 definition, \CFA creates a default and copy constructor, destructor and
 assignment (like \Cpp). It is possible to define constructors/destructors for
 basic and existing types.
+basic and existing types (unlike \Cpp).
 \section{Polymorphism}
 …
         do_once(value);
+}
 void do_once(int i) { ... }  // provide assertion
 int i;
+void do_once(@int@ i) { ... }  // provide assertion
+@int@ i;
 do_twice(i); // implicitly pass assertion do_once to do_twice
 \end{cfa}
 …
 declarations instead of parameters, returns, and local variable declarations.
 \begin{cfa}
 forall(dtype T)
+forall(dtype @T@)
 struct node {
+        node(T) * next;  // generic linked node
+        T * data;
+}
+        node(@T@) * next;  // generic linked node
+        @T@ * data;
+}
+node(@int@) inode;
 \end{cfa}
 The generic type @node(T)@ is an example of a polymorphic-type usage.  Like \Cpp
 templates usage, a polymorphic-type usage must specify a type parameter.
+template usage, a polymorphic-type usage must specify a type parameter.
 There are many other polymorphism features in \CFA but these are the ones used
 by the exception system.
 \section{Concurrency}
 \CFA has a number of concurrency features: @thread@, @monitor@, @mutex@
 parameters, @coroutine@ and @generator@. The two features that interact with
 the exception system are @thread@ and @coroutine@; they and their supporting
+\section{Control Flow}
+\CFA has a number of advanced control-flow features: @generator@, @coroutine@, @monitor@, @mutex@ parameters, and @thread@.
+The two features that interact with
+the exception system are @coroutine@ and @thread@; they and their supporting
 constructs are described here.
 …
 CountUp countup;
 \end{cfa}
 Each coroutine has @main@ function, which takes a reference to a coroutine
+Each coroutine has a @main@ function, which takes a reference to a coroutine
 object and returns @void@.
 \begin{cfa}[numbers=left]
 …
 In this function, or functions called by this function (helper functions), the
 @suspend@ statement is used to return execution to the coroutine's caller
 without terminating the coroutine.
+without terminating the coroutine's function.
 A coroutine is resumed by calling the @resume@ function, \eg @resume(countup)@.
 …
 @resume(countup).next@.
 \subsection{Monitors and Mutex}
+\subsection{Monitor and Mutex Parameter}
 Concurrency does not guarantee ordering; without ordering results are
 non-deterministic. To claw back ordering, \CFA uses monitors and @mutex@
 …
 and only one runs at a time.
 \subsection{Threads}
+\subsection{Thread}
 Functions, generators, and coroutines are sequential so there is only a single
 (but potentially sophisticated) execution path in a program. Threads introduce
 …
 monitors and mutex parameters. For threads to work safely with other threads,
 also requires mutual exclusion in the form of a communication rendezvous, which
 also supports internal synchronization as for mutex objects. For exceptions
 only the basic two basic operations are important: thread fork and join.
+also supports internal synchronization as for mutex objects. For exceptions,
+only two basic thread operations are important: fork and join.
 Threads are created like coroutines with an associated @main@ function:

doc/theses/andrew_beach_MMath/features.tex

-              rfeacef9
+              r5407cdc
 This chapter covers the design and user interface of the \CFA
+exception-handling mechanism.
+exception-handling mechanism (EHM). % or exception system.
+We will begin with an overview of EHMs in general. It is not a strict
+definition of all EHMs nor an exaustive list of all possible features.
+However it does cover the most common structure and features found in them.
+% We should cover what is an exception handling mechanism and what is an
+% exception before this. Probably in the introduction. Some of this could
+% move there.
+\paragraph{Raise / Handle}
+An exception operation has two main parts: raise and handle.
+These terms are sometimes also known as throw and catch but this work uses
+throw/catch as a particular kind of raise/handle.
+These are the two parts that the user will write themselves and may
+be the only two pieces of the EHM that have any syntax in the language.
+\subparagraph{Raise}
+The raise is the starting point for exception handling. It marks the beginning
+of exception handling by \newterm{raising} an excepion, which passes it to
+the EHM.
+Some well known examples include the @throw@ statements of \Cpp and Java and
+the \codePy{raise} statement from Python. In real systems a raise may preform
+some other work (such as memory management) but for the purposes of this
+overview that can be ignored.
+\subparagraph{Handle}
+The purpose of most exception operations is to run some user code to handle
+that exception. This code is given, with some other information, in a handler.
+A handler has three common features: the previously mentioned user code, a
+region of code they cover and an exception label/condition that matches
+certain exceptions.
+Only raises inside the covered region and raising exceptions that match the
+label can be handled by a given handler.
+Different EHMs will have different rules to pick a handler
+if multipe handlers could be used such as ``best match" or ``first found".
+The @try@ statements of \Cpp, Java and Python are common examples. All three
+also show another common feature of handlers, they are grouped by the covered
+region.
+\paragraph{Propagation}
+After an exception is raised comes what is usually the biggest step for the
+EHM: finding and setting up the handler. The propogation from raise to
+handler can be broken up into three different tasks: searching for a handler,
+matching against the handler and installing the handler.
+\subparagraph{Searching}
+The EHM begins by searching for handlers that might be used to handle
+the exception. Searching is usually independent of the exception that was
+thrown as it looks for handlers that have the raise site in their covered
+region.
+This includes handlers in the current function, as well as any in callers
+on the stack that have the function call in their covered region.
+\subparagraph{Matching}
+Each handler found has to be matched with the raised exception. The exception
+label defines a condition that be use used with exception and decides if
+there is a match or not.
+In languages where the first match is used this step is intertwined with
+searching, a match check is preformed immediately after the search finds
+a possible handler.
+\subparagraph{Installing}
+After a handler is chosen it must be made ready to run.
+The implementation can vary widely to fit with the rest of the
+design of the EHM. The installation step might be trivial or it could be
+the most expensive step in handling an exception. The latter tends to be the
+case when stack unwinding is involved.
+If a matching handler is not guarantied to be found the EHM will need a
+different course of action here in the cases where no handler matches.
+This is only required with unchecked exceptions as checked exceptions
+(such as in Java) can make than guaranty.
+This different action can also be installing a handler but it is usually an
+implicat and much more general one.
+\subparagraph{Hierarchy}
+A common way to organize exceptions is in a hierarchical structure.
+This is especially true in object-orientated languages where the
+exception hierarchy is a natural extension of the object hierarchy.
+Consider the following hierarchy of exceptions:
+\begin{center}
+\input{exception-hierarchy}
+\end{center}
+A handler labelled with any given exception can handle exceptions of that
+type or any child type of that exception. The root of the exception hierarchy
+(here \codeC{exception}) acts as a catch-all, leaf types catch single types
+and the exceptions in the middle can be used to catch different groups of
+related exceptions.
+This system has some notable advantages, such as multiple levels of grouping,
+the ability for libraries to add new exception types and the isolation
+between different sub-hierarchies.
+This design is used in \CFA even though it is not a object-orientated
+language using different tools to create the hierarchy.
+% Could I cite the rational for the Python IO exception rework?
+\paragraph{Completion}
+After the handler has finished the entire exception operation has to complete
+and continue executing somewhere else. This step is usually simple,
+both logically and in its implementation, as the installation of the handler
+is usually set up to do most of the work.
+The EHM can return control to many different places,
+the most common are after the handler definition and after the raise.
+\paragraph{Communication}
+For effective exception handling, additional information is usually passed
+from the raise to the handler.
+So far only communication of the exceptions' identity has been covered.
+A common method is putting fields into the exception instance and giving the
+handler access to them.
 \section{Virtuals}
+Virtual types and casts are not part of the exception system nor are they
+required for an exception system. But an object-oriented style hierarchy is a
+great way of organizing exceptions so a minimal virtual system has been added
+to \CFA.
+The pattern of a simple hierarchy was borrowed from object-oriented
+programming was chosen for several reasons.
+The first is that it allows new exceptions to be added in user code
+and in libraries independently of each other. Another is it allows for
+different levels of exception grouping (all exceptions, all IO exceptions or
+a particular IO exception). Also it also provides a simple way of passing
+data back and forth across the throw.
+Virtual types and casts are not required for a basic exception-system but are
+useful for advanced exception features. However, \CFA is not object-oriented so
+there is no obvious concept of virtuals. Hence, to create advanced exception
+features for this work, I needed to design and implement a virtual-like
+system for \CFA.
+% NOTE: Maybe we should but less of the rational here.
+Object-oriented languages often organized exceptions into a simple hierarchy,
+\eg Java.
+\begin{center}
+\setlength{\unitlength}{4000sp}%
+\begin{picture}(1605,612)(2011,-1951)
+\put(2100,-1411){\vector(1, 0){225}}
+\put(3450,-1411){\vector(1, 0){225}}
+\put(3550,-1411){\line(0,-1){225}}
+\put(3550,-1636){\vector(1, 0){150}}
+\put(3550,-1636){\line(0,-1){225}}
+\put(3550,-1861){\vector(1, 0){150}}
+\put(2025,-1490){\makebox(0,0)[rb]{\LstBasicStyle{exception}}}
+\put(2400,-1460){\makebox(0,0)[lb]{\LstBasicStyle{arithmetic}}}
+\put(3750,-1460){\makebox(0,0)[lb]{\LstBasicStyle{underflow}}}
+\put(3750,-1690){\makebox(0,0)[lb]{\LstBasicStyle{overflow}}}
+\put(3750,-1920){\makebox(0,0)[lb]{\LstBasicStyle{zerodivide}}}
+\end{picture}%
+\end{center}
+The hierarchy provides the ability to handle an exception at different degrees
+of specificity (left to right). Hence, it is possible to catch a more general
+exception-type in higher-level code where the implementation details are
+unknown, which reduces tight coupling to the lower-level implementation.
+Otherwise, low-level code changes require higher-level code changes, \eg,
+changing from raising @underflow@ to @overflow@ at the low level means changing
+the matching catch at the high level versus catching the general @arithmetic@
+exception. In detail, each virtual type may have a parent and can have any
+number of children. A type's descendants are its children and its children's
+descendants. A type may not be its own descendant.
+The exception hierarchy allows a handler (@catch@ clause) to match multiple
+exceptions, \eg a base-type handler catches both base and derived
+exception-types.
+\begin{cfa}
+try {
+        ...
+} catch(arithmetic &) {
+        ... // handle arithmetic, underflow, overflow, zerodivide
+}
+\end{cfa}
+Most exception mechanisms perform a linear search of the handlers and select
+the first matching handler, so the order of handers is now important because
+matching is many to one.
+Each virtual type needs an associated virtual table. A virtual table is a
+structure with fields for all the virtual members of a type. A virtual type has
+all the virtual members of its parent and can add more. It may also update the
+values of the virtual members and often does.
+Virtual types and casts are not part of \CFA's EHM nor are they required for
+any EHM. But \CFA uses a hierarchial system of exceptions and this feature
+is leveraged to create that.
+% Maybe talk about why the virtual system is so minimal.
+% Created for but not a part of the exception system.
+The virtual system supports multiple ``trees" of types. Each tree is
+a simple hierarchy with a single root type. Each type in a tree has exactly
+one parent -- except for the root type which has zero parents -- and any
+number of children.
+Any type that belongs to any of these trees is called a virtual type.
+% A type's ancestors are its parent and its parent's ancestors.
+% The root type has no ancestors.
+% A type's decendents are its children and its children's decendents.
+Every virtual type also has a list of virtual members. Children inherit
+their parent's list of virtual members but may add new members to it.
+It is important to note that these are virtual members, not virtual methods
+of object-orientated programming, and can be of any type.
+However, since \CFA has function pointers and they are allowed, virtual
+members can be used to mimic virtual methods.
+Each virtual type has a unique id.
+This unique id and all the virtual members are combined
+into a virtual table type. Each virtual type has a pointer to a virtual table
+as a hidden field.
+Up until this point the virtual system is similar to ones found in
+object-orientated languages but this where \CFA diverges. Objects encapsulate a
+single set of behaviours in each type, universally across the entire program,
+and indeed all programs that use that type definition. In this sense the
+types are ``closed" and cannot be altered.
+In \CFA types do not encapsulate any behaviour. Traits are local and
+types can begin to statify a trait, stop satifying a trait or satify the same
+trait in a different way at any lexical location in the program.
+In this sense they are ``open" as they can change at any time. This means it
+is implossible to pick a single set of functions that repersent the type's
+implementation across the program.
+\CFA side-steps this issue by not having a single virtual table for each
+type. A user can define virtual tables which are filled in at their
+declaration and given a name. Anywhere that name is visible, even if it was
+defined locally inside a function (although that means it will not have a
+static lifetime), it can be used.
+Specifically, a virtual type is ``bound" to a virtual table which
+sets the virtual members for that object. The virtual members can be accessed
+through the object.
 While much of the virtual infrastructure is created, it is currently only used
 …
 \Cpp syntax for special casts. Both the type of @EXPRESSION@ and @TYPE@ must be
 a pointer to a virtual type.
 The cast dynamically checks if the @EXPRESSION@ type is the same or a subtype
+The cast dynamically checks if the @EXPRESSION@ type is the same or a sub-type
 of @TYPE@, and if true, returns a pointer to the
 @EXPRESSION@ object, otherwise it returns @0p@ (null pointer).
 …
 \end{cfa}
 The trait is defined over two types, the exception type and the virtual table
 type. This should be one-to-one, each exception type has only one virtual
+type. This should be one-to-one: each exception type has only one virtual
 table type and vice versa. The only assertion in the trait is
 @get_exception_vtable@, which takes a pointer of the exception type and
 returns a reference to the virtual table type instance.
+% TODO: This section, and all references to get_exception_vtable, are
+% out-of-data. Perhaps wait until the update is finished before rewriting it.
 The function @get_exception_vtable@ is actually a constant function.
 Recardless of the value passed in (including the null pointer) it should
+Regardless of the value passed in (including the null pointer) it should
 return a reference to the virtual table instance for that type.
 The reason it is a function instead of a constant is that it make type
 …
 % similar system I know of (except Agda's I guess) so I took it out.
+There are two more traits for exceptions @is_termination_exception@ and
+@is_resumption_exception@. They are defined as follows:
+There are two more traits for exceptions defined as follows:
 \begin{cfa}
 trait is_termination_exception(
 …
 };
 \end{cfa}
+In other words they make sure that a given type and virtual type is an
+exception and defines one of the two default handlers. These default handlers
+are used in the main exception handling operations \see{Exception Handling}
+and their use will be detailed there.
+However all three of these traits can be trickly to use directly.
+There is a bit of repetition required but
+Both traits ensure a pair of types are an exception type and its virtual table
+and defines one of the two default handlers. The default handlers are used
+as fallbacks and are discussed in detail in \VRef{s:ExceptionHandling}.
+However, all three of these traits can be tricky to use directly.
+While there is a bit of repetition required,
 the largest issue is that the virtual table type is mangled and not in a user
 facing way. So there are three macros that can be used to wrap these traits
 when you need to refer to the names:
+facing way. So these three macros are provided to wrap these traits to
+simplify referring to the names:
 @IS_EXCEPTION@, @IS_TERMINATION_EXCEPTION@ and @IS_RESUMPTION_EXCEPTION@.
 All take one or two arguments. The first argument is the name of the
 exception type. Its unmangled and mangled form are passed to the trait.
+All three take one or two arguments. The first argument is the name of the
+exception type. The macro passes its unmangled and mangled form to the trait.
 The second (optional) argument is a parenthesized list of polymorphic
 arguments. This argument should only with polymorphic exceptions and the
 list will be passed to both types.
 In the current set-up the base name and the polymorphic arguments have to
 match so these macros can be used without losing flexability.
+arguments. This argument is only used with polymorphic exceptions and the
+list is be passed to both types.
+In the current set-up, the two types always have the same polymorphic
+arguments so these macros can be used without losing flexibility.
 For example consider a function that is polymorphic over types that have a
 …
 \section{Exception Handling}
 \CFA provides two kinds of exception handling, termination and resumption.
+These twin operations are the core of the exception handling mechanism and
 are the reason for the features of exceptions.
+\label{s:ExceptionHandling}
+\CFA provides two kinds of exception handling: termination and resumption.
+These twin operations are the core of \CFA's exception handling mechanism.
 This section will cover the general patterns shared by the two operations and
 then go on to cover the details each individual operation.
+Both operations follow the same set of steps to do their operation. They both
+start with the user preforming a throw on an exception.
+Then there is the search for a handler, if one is found than the exception
+is caught and the handler is run. After that control returns to normal
+execution.
+Both operations follow the same set of steps.
+Both start with the user preforming a raise on an exception.
+Then the exception propogates up the stack.
+If a handler is found the exception is caught and the handler is run.
+After that control returns to normal execution.
 If the search fails a default handler is run and then control
+returns to normal execution immediately. That is where the default handlers
+@defaultTermiationHandler@ and @defaultResumptionHandler@ are used.
+returns to normal execution after the raise.
+This general description covers what the two kinds have in common.
+Differences include how propogation is preformed, where exception continues
+after an exception is caught and handled and which default handler is run.
 \subsection{Termination}
 \label{s:Termination}
+Termination handling is more familiar kind and used in most programming
+Termination handling is the familiar kind and used in most programming
 languages with exception handling.
+It is dynamic, non-local goto. If a throw is successful then the stack will
+be unwound and control will (usually) continue in a different function on
+the call stack. They are commonly used when an error has occured and recovery
+is impossible in the current function.
+It is dynamic, non-local goto. If the raised exception is matched and
+handled the stack is unwound and control will (usually) continue the function
+on the call stack that defined the handler.
+Termination is commonly used when an error has occurred and recovery is
+impossible locally.
 % (usually) Control can continue in the current function but then a different
 % control flow construct should be used.
 A termination throw is started with the @throw@ statement:
+A termination raise is started with the @throw@ statement:
 \begin{cfa}
 throw EXPRESSION;
 \end{cfa}
 The expression must return a reference to a termination exception, where the
+termination exception is any type that satifies @is_termination_exception@
+at the call site.
+Through \CFA's trait system the functions in the traits are passed into the
+throw code. A new @defaultTerminationHandler@ can be defined in any scope to
+termination exception is any type that satisfies the trait
+@is_termination_exception@ at the call site.
+Through \CFA's trait system the trait functions are implicity passed into the
+throw code and the EHM.
+A new @defaultTerminationHandler@ can be defined in any scope to
 change the throw's behavior (see below).
+The throw will copy the provided exception into managed memory. It is the
+user's responcibility to ensure the original exception is cleaned up if the
+stack is unwound (allocating it on the stack should be sufficient).
+Then the exception system searches the stack using the copied exception.
+It starts starts from the throw and proceeds to the base of the stack,
+The throw will copy the provided exception into managed memory to ensure
+the exception is not destroyed if the stack is unwound.
+It is the user's responsibility to ensure the original exception is cleaned
+up wheither the stack is unwound or not. Allocating it on the stack is
+usually sufficient.
+Then propogation starts with the search. \CFA uses a ``first match" rule so
+matching is preformed with the copied exception as the search continues.
+It starts from the throwing function and proceeds to the base of the stack,
 from callee to caller.
 At each stack frame, a check is made for resumption handlers defined by the
 …
 try {
         GUARDED_BLOCK
 } catch (EXCEPTION_TYPE$\(_1\)$ * NAME$\(_1\)$) {
+} catch (EXCEPTION_TYPE$\(_1\)$ * [NAME$\(_1\)$]) {
         HANDLER_BLOCK$\(_1\)$
 } catch (EXCEPTION_TYPE$\(_2\)$ * NAME$\(_2\)$) {
+} catch (EXCEPTION_TYPE$\(_2\)$ * [NAME$\(_2\)$]) {
         HANDLER_BLOCK$\(_2\)$
+}
 \end{cfa}
 When viewed on its own a try statement will simply exceute the statements in
 @GUARDED_BLOCK@ and when those are finished the try statement finishes.
+When viewed on its own, a try statement will simply execute the statements
+in @GUARDED_BLOCK@ and when those are finished the try statement finishes.
 However, while the guarded statements are being executed, including any
+functions they invoke, all the handlers following the try block are now
+or any functions invoked from those
+statements, throws an exception, and the exception
+is not handled by a try statement further up the stack, the termination
+handlers are searched for a matching exception type from top to bottom.
+Exception matching checks the representation of the thrown exception-type is
+the same or a descendant type of the exception types in the handler clauses. If
+it is the same of a descendent of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$ is
+invoked functions, all the handlers in the statement are now on the search
+path. If a termination exception is thrown and not handled further up the
+stack they will be matched against the exception.
+Exception matching checks the handler in each catch clause in the order
+they appear, top to bottom. If the representation of the thrown exception type
+is the same or a descendant of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$
+(if provided) is
 bound to a pointer to the exception and the statements in @HANDLER_BLOCK@$_i$
 are executed. If control reaches the end of the handler, the exception is
 freed and control continues after the try statement.
+If no handler is found during the search then the default handler is run.
+If no termination handler is found during the search then the default handler
+(@defaultTerminationHandler@) is run.
 Through \CFA's trait system the best match at the throw sight will be used.
 This function is run and is passed the copied exception. After the default
 handler is run control continues after the throw statement.
+There is a global @defaultTerminationHandler@ that cancels the current stack
+with the copied exception. However it is generic over all exception types so
+new default handlers can be defined for different exception types and so
+different exception types can have different default handlers.
+There is a global @defaultTerminationHandler@ that is polymorphic over all
+exception types. Since it is so general a more specific handler can be
+defined and will be used for those types, effectively overriding the handler
+for particular exception type.
+The global default termination handler performs a cancellation
+\see{\VRef{s:Cancellation}} on the current stack with the copied exception.
 \subsection{Resumption}
 \label{s:Resumption}
 Resumption exception handling is a less common form than termination but is
 just as old~\cite{Goodenough75} and is in some sense simpler.
 It is a dynamic, non-local function call. If the throw is successful a
+closure will be taken from up the stack and executed, after which the throwing
 function will continue executing.
 These are most often used when an error occured and if the error is repaired
+Resumption exception handling is less common than termination but is
+just as old~\cite{Goodenough75} and is simpler in many ways.
+It is a dynamic, non-local function call. If the raised exception is
+matched a closure will be taken from up the stack and executed,
+after which the raising function will continue executing.
+These are most often used when an error occurred and if the error is repaired
 then the function can continue.
 …
 throwResume EXPRESSION;
 \end{cfa}
+The semantics of the @throwResume@ statement are like the @throw@, but the
+expression has return a reference a type that satifies the trait
+@is_resumption_exception@. The assertions from this trait are available to
+It works much the same way as the termination throw.
+The expression must return a reference to a resumption exception,
+where the resumption exception is any type that satisfies the trait
+@is_resumption_exception@ at the call site.
+The assertions from this trait are available to
 the exception system while handling the exception.
+At runtime, no copies are made. As the stack is not unwound the exception and
+At run-time, no exception copy is made.
+As the stack is not unwound the exception and
 any values on the stack will remain in scope while the resumption is handled.
+Then the exception system searches the stack using the provided exception.
+It starts starts from the throw and proceeds to the base of the stack,
+from callee to caller.
+The EHM then begins propogation. The search starts from the raise in the
+resuming function and proceeds to the base of the stack, from callee to caller.
 At each stack frame, a check is made for resumption handlers defined by the
 @catchResume@ clauses of a @try@ statement.
 …
 try {
         GUARDED_BLOCK
 } catchResume (EXCEPTION_TYPE$\(_1\)$ * NAME$\(_1\)$) {
+} catchResume (EXCEPTION_TYPE$\(_1\)$ * [NAME$\(_1\)$]) {
         HANDLER_BLOCK$\(_1\)$
 } catchResume (EXCEPTION_TYPE$\(_2\)$ * NAME$\(_2\)$) {
+} catchResume (EXCEPTION_TYPE$\(_2\)$ * [NAME$\(_2\)$]) {
         HANDLER_BLOCK$\(_2\)$
+}
 \end{cfa}
+If the handlers are not involved in a search this will simply execute the
+@GUARDED_BLOCK@ and then continue to the next statement.
+Its purpose is to add handlers onto the stack.
+(Note, termination and resumption handlers may be intermixed in a @try@
+statement but the kind of throw must be the same as the handler for it to be
+considered as a possible match.)
+If a search for a resumption handler reaches a try block it will check each
+@catchResume@ clause, top-to-bottom.
+At each handler if the thrown exception is or is a child type of
+@EXCEPTION_TYPE@$_i$ then the a pointer to the exception is bound to
+@NAME@$_i$ and then @HANDLER_BLOCK@$_i$ is executed. After the block is
+finished control will return to the @throwResume@ statement.
+% I wonder if there would be some good central place for this.
+Note that termination handlers and resumption handlers may be used together
+in a single try statement, intermixing @catch@ and @catchResume@ freely.
+Each type of handler will only interact with exceptions from the matching
+type of raise.
+When a try statement is executed it simply executes the statements in the
+@GUARDED_BLOCK@ and then finishes.
+However, while the guarded statements are being executed, including any
+invoked functions, all the handlers in the statement are now on the search
+path. If a resumption exception is reported and not handled further up the
+stack they will be matched against the exception.
+Exception matching checks the handler in each catch clause in the order
+they appear, top to bottom. If the representation of the thrown exception type
+is the same or a descendant of @EXCEPTION_TYPE@$_i$ then @NAME@$_i$
+(if provided) is bound to a pointer to the exception and the statements in
+@HANDLER_BLOCK@$_i$ are executed.
+If control reaches the end of the handler, execution continues after the
+the raise statement that raised the handled exception.
 Like termination, if no resumption handler is found, the default handler
 …
 call sight according to \CFA's overloading rules. The default handler is
 passed the exception given to the throw. When the default handler finishes
 execution continues after the throw statement.
+execution continues after the raise statement.
 There is a global @defaultResumptionHandler@ is polymorphic over all
 termination exceptions and preforms a termination throw on the exception.
 The @defaultTerminationHandler@ for that throw is matched at the original
 throw statement (the resumption @throwResume@) and it can be customized by
+The @defaultTerminationHandler@ for that raise is matched at the original
+raise statement (the resumption @throwResume@) and it can be customized by
 introducing a new or better match as well.
+% \subsubsection?
+\subsubsection{Resumption Marking}
 A key difference between resumption and termination is that resumption does
 not unwind the stack. A side effect that is that when a handler is matched
 …
 search and match the handler in the @catchResume@ clause. This will be
 call and placed on the stack on top of the try-block. The second throw then
 throws and will seach the same try block and put call another instance of the
+throws and will search the same try block and put call another instance of the
 same handler leading to an infinite loop.
 …
 can form with multiple handlers and different exception types.
+To prevent all of these cases we mask sections of the stack, or equvilantly
+the try statements on the stack, so that the resumption seach skips over
+them and continues with the next unmasked section of the stack.
+A section of the stack is marked when it is searched to see if it contains
+a handler for an exception and unmarked when that exception has been handled
+or the search was completed without finding a handler.
+% This might need a diagram. But it is an important part of the justification
+% of the design of the traversal order.
+\begin{verbatim}
+       throwResume2 ----------.
+            |                 |
+ generated from handler       |
+            |                 |
+         handler              |
+            |                 |
+        throwResume1 -----.   :
+            |             |   :
+           try            |   : search skip
+            |             |   :
+        catchResume  <----'   :
+            |                 |
+\end{verbatim}
+The rules can be remembered as thinking about what would be searched in
+termination. So when a throw happens in a handler; a termination handler
+skips everything from the original throw to the original catch because that
+part of the stack has been unwound, a resumption handler skips the same
+section of stack because it has been masked.
+A throw in a default handler will preform the same search as the original
+throw because; for termination nothing has been unwound, for resumption
+the mask will be the same.
+The symmetry with termination is why this pattern was picked. Other patterns,
+such as marking just the handlers that caught, also work but lack the
+symmetry whih means there is more to remember.
+To prevent all of these cases we mark try statements on the stack.
+A try statement is marked when a match check is preformed with it and an
+exception. The statement will be unmarked when the handling of that exception
+is completed or the search completes without finding a handler.
+While a try statement is marked its handlers are never matched, effectify
+skipping over it to the next try statement.
+\begin{center}
+\input{stack-marking}
+\end{center}
+These rules mirror what happens with termination.
+When a termination throw happens in a handler the search will not look at
+any handlers from the original throw to the original catch because that
+part of the stack has been unwound.
+A resumption raise in the same situation wants to search the entire stack,
+but it will not try to match the exception with try statements in the section
+that would have been unwound as they are marked.
+The symmetry between resumption termination is why this pattern was picked.
+Other patterns, such as marking just the handlers that caught, also work but
+lack the symmetry means there are less rules to remember.
 \section{Conditional Catch}
 …
 condition to further control which exceptions they handle:
 \begin{cfa}
 catch (EXCEPTION_TYPE * NAME ; CONDITION)
+catch (EXCEPTION_TYPE * [NAME] ; CONDITION)
 \end{cfa}
 First, the same semantics is used to match the exception type. Second, if the
 …
 matches. Otherwise, the exception search continues as if the exception type
 did not match.
+\begin{cfa}
+try {
+        f1 = open( ... );
+        f2 = open( ... );
+The condition matching allows finer matching by allowing the match to check
+more kinds of information than just the exception type.
+\begin{cfa}
+try {
+        handle1 = open( f1, ... );
+        handle2 = open( f2, ... );
+        handle3 = open( f3, ... );
         ...
 } catch( IOFailure * f ; fd( f ) == f1 ) {
+        // only handle IO failure for f1
+}
+\end{cfa}
+Note, catching @IOFailure@, checking for @f1@ in the handler, and reraising the
+exception if not @f1@ is different because the reraise does not examine any of
+remaining handlers in the current try statement.
+\section{Rethrowing}
+\colour{red}{From Andrew: I recomend we talk about why the language doesn't
+have rethrows/reraises instead.}
+\label{s:Rethrowing}
+        // Only handle IO failure for f1.
+} catch( IOFailure * f ; fd( f ) == f3 ) {
+        // Only handle IO failure for f3.
+}
+// Can't handle a failure relating to f2 here.
+\end{cfa}
+In this example the file that experianced the IO error is used to decide
+which handler should be run, if any at all.
+\begin{comment}
+% I know I actually haven't got rid of them yet, but I'm going to try
+% to write it as if I had and see if that makes sense:
+\section{Reraising}
+\label{s:Reraising}
 Within the handler block or functions called from the handler block, it is
 possible to reraise the most recently caught exception with @throw@ or
 …
 is part of an unwound stack frame. To prevent this problem, a new default
 handler is generated that does a program-level abort.
+\end{comment}
+\subsection{Comparison with Reraising}
+A more popular way to allow handlers to match in more detail is to reraise
+the exception after it has been caught if it could not be handled here.
+On the surface these two features seem interchangable.
+If we used @throw;@ to start a termination reraise then these two statements
+would have the same behaviour:
+\begin{cfa}
+try {
+    do_work_may_throw();
+} catch(exception_t * exc ; can_handle(exc)) {
+    handle(exc);
+}
+\end{cfa}
+\begin{cfa}
+try {
+    do_work_may_throw();
+} catch(exception_t * exc) {
+    if (can_handle(exc)) {
+        handle(exc);
+    } else {
+        throw;
+    }
+}
+\end{cfa}
+If there are further handlers after this handler only the first version will
+check them. If multiple handlers on a single try block could handle the same
+exception the translations get more complex but they are equivilantly
+powerful.
+Until stack unwinding comes into the picture. In termination handling, a
+conditional catch happens before the stack is unwound, but a reraise happens
+afterwards. Normally this might only cause you to loose some debug
+information you could get from a stack trace (and that can be side stepped
+entirely by collecting information during the unwind). But for \CFA there is
+another issue, if the exception isn't handled the default handler should be
+run at the site of the original raise.
+There are two problems with this: the site of the original raise doesn't
+exist anymore and the default handler might not exist anymore. The site will
+always be removed as part of the unwinding, often with the entirety of the
+function it was in. The default handler could be a stack allocated nested
+function removed during the unwind.
+This means actually trying to pretend the catch didn't happening, continuing
+the original raise instead of starting a new one, is infeasible.
+That is the expected behaviour for most languages and we can't replicate
+that behaviour.
 \section{Finally Clauses}
+\label{s:FinallyClauses}
 Finally clauses are used to preform unconditional clean-up when leaving a
 scope. They are placed at the end of a try statement:
+scope and are placed at the end of a try statement after any handler clauses:
 \begin{cfa}
 try {
 …
 Execution of the finally block should always finish, meaning control runs off
+the end of the block. This requirement ensures always continues as if the
+finally clause is not present, \ie finally is for cleanup not changing control
+flow. Because of this requirement, local control flow out of the finally block
+the end of the block. This requirement ensures control always continues as if
+the finally clause is not present, \ie finally is for cleanup not changing
+control flow.
+Because of this requirement, local control flow out of the finally block
 is forbidden. The compiler precludes any @break@, @continue@, @fallthru@ or
 @return@ that causes control to leave the finally block. Other ways to leave
 the finally block, such as a long jump or termination are much harder to check,
 and at best requiring additional run-time overhead, and so are mearly
+and at best requiring additional run-time overhead, and so are only
 discouraged.
 Not all languages with exceptions have finally clauses. Notably \Cpp does
+Not all languages with unwinding have finally clauses. Notably \Cpp does
 without it as descructors serve a similar role. Although destructors and
 finally clauses can be used in many of the same areas they have their own
 use cases like top-level functions and lambda functions with closures.
 Destructors take a bit more work to set up but are much easier to reuse while
+finally clauses are good for once offs and can include local information.
+finally clauses are good for one-off uses and
+can easily include local information.
 \section{Cancellation}
+\label{s:Cancellation}
 Cancellation is a stack-level abort, which can be thought of as as an
 uncatchable termination. It unwinds the entirety of the current stack, and if
+uncatchable termination. It unwinds the entire current stack, and if
 possible forwards the cancellation exception to a different stack.
 …
 There is no special statement for starting a cancellation; instead the standard
 library function @cancel_stack@ is called passing an exception. Unlike a
 throw, this exception is not used in matching only to pass information about
+raise, this exception is not used in matching only to pass information about
 the cause of the cancellation.
 (This also means matching cannot fail so there is no default handler either.)
 After @cancel_stack@ is called the exception is copied into the exception
 handling mechanism's memory. Then the entirety of the current stack is
+(This also means matching cannot fail so there is no default handler.)
+After @cancel_stack@ is called the exception is copied into the EHM's memory
+and the current stack is
 unwound. After that it depends one which stack is being cancelled.
 \begin{description}
 \item[Main Stack:]
 The main stack is the one used by the program main at the start of execution,
+and is the only stack in a sequential program. Even in a concurrent program
+the main stack is only dependent on the environment that started the program.
+Hence, when the main stack is cancelled there is nowhere else in the program
+to notify. After the stack is unwound, there is a program-level abort.
+and is the only stack in a sequential program.
+After the main stack is unwound there is a program-level abort.
+There are two reasons for this. The first is that it obviously had to do this
+in a sequential program as there is nothing else to notify and the simplicity
+of keeping the same behaviour in sequential and concurrent programs is good.
+Also, even in concurrent programs there is no stack that an innate connection
+to, so it would have be explicitly managed.
 \item[Thread Stack:]
+A thread stack is created for a @thread@ object or object that satisfies the
+@is_thread@ trait. A thread only has two points of communication that must
+happen: start and join. As the thread must be running to perform a
+cancellation, it must occur after start and before join, so join is used
+for communication here.
+After the stack is unwound, the thread halts and waits for
+another thread to join with it. The joining thread checks for a cancellation,
+and if present, resumes exception @ThreadCancelled@.
+There is a subtle difference between the explicit join (@join@ function) and
+implicit join (from a destructor call). The explicit join takes the default
+handler (@defaultResumptionHandler@) from its calling context, which is used if
+the exception is not caught. The implicit join does a program abort instead.
+This semantics is for safety. If an unwind is triggered while another unwind
+is underway only one of them can proceed as they both want to ``consume'' the
+stack. Letting both try to proceed leads to very undefined behaviour.
+Both termination and cancellation involve unwinding and, since the default
+@defaultResumptionHandler@ preforms a termination that could more easily
+happen in an implicate join inside a destructor. So there is an error message
+and an abort instead.
+\todo{Perhaps have a more general disucssion of unwind collisions before
+this point.}
+The recommended way to avoid the abort is to handle the intial resumption
+from the implicate join. If required you may put an explicate join inside a
+finally clause to disable the check and use the local
+@defaultResumptionHandler@ instead.
+\item[Coroutine Stack:] A coroutine stack is created for a @coroutine@ object
+or object that satisfies the @is_coroutine@ trait. A coroutine only knows of
+two other coroutines, its starter and its last resumer. Of the two the last
+resumer has the tightest coupling to the coroutine it activated and the most
+up-to-date information.
+Hence, cancellation of the active coroutine is forwarded to the last resumer
+after the stack is unwound. When the resumer restarts, it resumes exception
+@CoroutineCancelled@, which is polymorphic over the coroutine type and has a
+pointer to the cancelled coroutine.
+The resume function also has an assertion that the @defaultResumptionHandler@
+for the exception. So it will use the default handler like a regular throw.
+A thread stack is created for a \CFA @thread@ object or object that satisfies
+the @is_thread@ trait.
+After a thread stack is unwound there exception is stored until another
+thread attempts to join with it. Then the exception @ThreadCancelled@,
+which stores a reference to the thread and to the exception passed to the
+cancellation, is reported from the join.
+There is one difference between an explicit join (with the @join@ function)
+and an implicit join (from a destructor call). The explicit join takes the
+default handler (@defaultResumptionHandler@) from its calling context while
+the implicit join provides its own which does a program abort if the
+@ThreadCancelled@ exception cannot be handled.
+Communication is done at join because a thread only has to have to points of
+communication with other threads: start and join.
+Since a thread must be running to perform a cancellation (and cannot be
+cancelled from another stack), the cancellation must be after start and
+before the join. So join is the one that we will use.
+% TODO: Find somewhere to discuss unwind collisions.
+The difference between the explicit and implicit join is for safety and
+debugging. It helps prevent unwinding collisions by avoiding throwing from
+a destructor and prevents cascading the error across multiple threads if
+the user is not equipped to deal with it.
+Also you can always add an explicit join if that is the desired behaviour.
+\item[Coroutine Stack:]
+A coroutine stack is created for a @coroutine@ object or object that
+satisfies the @is_coroutine@ trait.
+After a coroutine stack is unwound control returns to the resume function
+that most recently resumed it. The resume statement reports a
+@CoroutineCancelled@ exception, which contains a references to the cancelled
+coroutine and the exception used to cancel it.
+The resume function also takes the @defaultResumptionHandler@ from the
+caller's context and passes it to the internal report.
+A coroutine knows of two other coroutines, its starter and its last resumer.
+The starter has a much more distant connection while the last resumer just
+(in terms of coroutine state) called resume on this coroutine, so the message
+is passed to the latter.
 \end{description}

doc/theses/andrew_beach_MMath/future.tex

-              rfeacef9
+              r5407cdc
 patterns to find the handler.
+\section{Checked Exceptions}
+Checked exceptions make exceptions part of a function's type by adding the
+exception signature. An exception signature must declare all checked
+exceptions that could propogate from the function (either because they were
+raised inside the function or came from a sub-function). This improves safety
+by making sure every checked exception is either handled or consciously
+passed on.
+However checked exceptions were never seriously considered for this project
+for two reasons. The first is due to time constraints, even copying an
+existing checked exception system would be pushing the remaining time and
+trying to address the second problem would take even longer. The second
+problem is that checked exceptions have some real usability trade-offs in
+exchange for the increased safety.
+These trade-offs are most problematic when trying to pass exceptions through
+higher-order functions from the functions the user passed into the
+higher-order function. There are no well known solutions to this problem
+that were statifactory for \CFA (which carries some of C's flexability
+over safety design) so one would have to be researched and developed.
+Follow-up work might add checked exceptions to \CFA, possibly using
+polymorphic exception signatures, a form of tunneling\cite{Zhang19} or
+checked and unchecked raises.
 \section{Zero-Cost Try}
 \CFA does not have zero-cost try-statements because the compiler generates C

doc/theses/andrew_beach_MMath/implement.tex

-              rfeacef9
+              r5407cdc
 library.
+\subsection{Virtual Type}
+Virtual types only have one change to their structure, the addition of a
+pointer to the virtual table. This is always the first field so that
+if it is cast to a supertype the field's location is still known.
+This field is set as part of all new generated constructors.
+\todo{They only come as part exceptions and don't work.}
+After the object is created the field is constant.
+However it can be read from, internally it is just a regular field called
+@virtual_table@. Dereferencing it gives the virtual table and access to the
+type's virtual members.
 \subsection{Virtual Table}
+Every time a virtual type is defined the new virtual table type must also be
+defined.
+The unique instance is important because the address of the virtual table
+instance is used as the identifier for the virtual type. So a pointer to the
+virtual table and the ID for the virtual type are interchangable.
+\todo{Unique instances might be going so we will have to talk about the new
+system instead.}
+The first step in putting it all together is to create the virtual table type.
+The virtual table type is just a structure and can be described in terms of
+its fields. The first field is always the parent type ID (or a pointer to
+the parent virtual table) or 0 (the null pointer).
+Next are other fields on the parent virtual table are repeated.
+Finally are the fields used to store any new virtual members of the new
+The virtual type
 The virtual system is accessed through a private constant field inserted at the
 beginning of every virtual type, called the virtual-table pointer. This field
 points at a type's virtual table and is assigned during the object's
 construction.  The address of a virtual table acts as the unique identifier for
+construction. The address of a virtual table acts as the unique identifier for
 the virtual type, and the first field of a virtual table is a pointer to the
 parent virtual-table or @0p@.  The remaining fields are duplicated from the
+parent virtual-table or @0p@. The remaining fields are duplicated from the
 parent tables in this type's inheritance chain, followed by any fields this type
 introduces. Parent fields are duplicated so they can be changed (\CC
 \lstinline[language=c++]|override|), so that references to the dispatched type
+introduces. Parent fields are duplicated so they can be changed (all virtual
+members are overridable), so that references to the dispatched type
 are replaced with the current virtual type.
-\PAB{Can you create a simple diagram of the layout?}
 % These are always taken by pointer or reference.
+% Simple ascii diragram:
+\begin{verbatim}
+parent_pointer  \
+parent_field0   |
+...             | Same layout as parent.
+parent_fieldN   /
+child_field0
+...
+child_fieldN
+\end{verbatim}
+\todo{Refine the diagram}
 % For each virtual type, a virtual table is constructed. This is both a new type
 …
 A virtual table is created when the virtual type is created. The name of the
 type is created by mangling the name of the base type. The name of the instance
 is also generated by name mangling.  The fields are initialized automatically.
+is also generated by name mangling. The fields are initialized automatically.
 The parent field is initialized by getting the type of the parent field and
 using that to calculate the mangled name of the parent's virtual table type.
 …
 \begin{sloppypar}
 Coroutines and threads need instances of @CoroutineCancelled@ and
 @ThreadCancelled@ respectively to use all of their functionality.  When a new
+@ThreadCancelled@ respectively to use all of their functionality. When a new
 data type is declared with @coroutine@ or @thread@ the forward declaration for
 the instance is created as well. The definition of the virtual table is created
 …
 The function is
 \begin{cfa}
+void * __cfa__virtual_cast( struct __cfa__parent_vtable const * parent,
+void * __cfa__virtual_cast(
+        struct __cfa__parent_vtable const * parent,
         struct __cfa__parent_vtable const * const * child );
+}
 \end{cfa}
+and it is implemented in the standard library. It takes a pointer to the target
+type's virtual table and the object pointer being cast. The function performs a
+linear search starting at the object's virtual-table and walking through the
+the parent pointers, checking to if it or any of its ancestors are the same as
+the target-type virtual table-pointer.
+For the generated code, a forward declaration of the virtual works as follows.
+There is a forward declaration of @__cfa__virtual_cast@ in every \CFA file so
+it can just be used. The object argument is the expression being cast so that
+is just placed in the argument list.
+To build the target type parameter, the compiler creates a mapping from
+concrete type-name -- so for polymorphic types the parameters are filled in --
+to virtual table address. Every virtual table declaration is added to the this
+table; repeats are ignored unless they have conflicting definitions.  Note,
+these declarations do not have to be in scope, but they should usually be
+introduced as part of the type definition.
+\PAB{I do not understood all of \VRef{s:VirtualSystem}. I think you need to
+write more to make it clear.}
+and it is implemented in the standard library. The structure reperents the
+head of a vtable which is the pointer to the parent virtual table. The
+@parent@ points directly at the parent type virtual table while the @child@
+points at the object of the (possibe) child type.
+In terms of the virtual cast expression, @parent@ comes from looking up the
+type being cast to and @child@ is the result of the expression being cast.
+Because the complier outputs C code, some type C type casts are also used.
+The last bit of glue is an map that saves every virtual type the compiler
+sees. This is used to check the type used in a virtual cast is a virtual
+type and to get its virtual table.
+(It also checks for conflicting definitions.)
+Inside the function it is a simple conditional. If the type repersented by
+@parent@ is or is an ancestor of the type repersented by @*child@ (it
+requires one more level of derefence to pass through the object) then @child@
+is returned, otherwise the null pointer is returned.
+The check itself is preformed is a simple linear search. If the child
+virtual table or any of its ancestors (which are retreved through the first
+field of every virtual table) are the same as the parent virtual table then
+the cast succeeds.
 \section{Exceptions}
 …
 stack. On function entry and return, unwinding is handled directly by the code
 embedded in the function. Usually, the stack-frame size is known statically
 based on parameter and local variable declarations.  For dynamically-sized
+based on parameter and local variable declarations. For dynamically-sized
 local variables, a runtime computation is necessary to know the frame
 size. Finally, a function's frame-size may change during execution as local
 …
 To use libunwind, each function must have a personality function and a Language
 Specific Data Area (LSDA).  The LSDA has the unique information for each
+Specific Data Area (LSDA). The LSDA has the unique information for each
 function to tell the personality function where a function is executing, its
 current stack frame, and what handlers should be checked.  Theoretically, the
+current stack frame, and what handlers should be checked. Theoretically, the
 LSDA can contain any information but conventionally it is a table with entries
 representing regions of the function and what has to be done there during
 …
 The GCC compilation flag @-fexceptions@ causes the generation of an LSDA and
+attaches its personality function. \PAB{to what is it attached?}  However, this
+flag only handles the cleanup attribute
+attaches its personality function. However, this
+flag only handles the cleanup attribute:
+\todo{Peter: What is attached? Andrew: It uses the .cfi\_personality directive
+and that's all I know.}
 \begin{cfa}
 void clean_up( int * var ) { ... }
 int avar __attribute__(( __cleanup(clean_up) ));
+int avar __attribute__(( cleanup(clean_up) ));
 \end{cfa}
+which is used on a variable and specifies a function, \eg @clean_up@, run when
+the variable goes out of scope. The function is passed a pointer to the object
+so it can be used to mimic destructors. However, this feature cannot be used to
+mimic @try@ statements.
+which is used on a variable and specifies a function, in this case @clean_up@,
+run when the variable goes out of scope.
+The function is passed a pointer to the object being removed from the stack
+so it can be used to mimic destructors.
+However, this feature cannot be used to mimic @try@ statements as it cannot
+control the unwinding.
 \subsection{Personality Functions}
 Personality functions have a complex interface specified by libunwind.  This
+Personality functions have a complex interface specified by libunwind. This
 section covers some of the important parts of the interface.
 A personality function performs four tasks, although not all have to be
 present.
+A personality function can preform different actions depending on how it is
+called.
 \begin{lstlisting}[language=C,{moredelim=**[is][\color{red}]{@}{@}}]
 typedef _Unwind_Reason_Code (*@_Unwind_Personality_Fn@) (
 …
 \item
 @_UA_SEARCH_PHASE@ specifies a search phase and tells the personality function
 to check for handlers.  If there is a handler in a stack frame, as defined by
+to check for handlers. If there is a handler in a stack frame, as defined by
 the language, the personality function returns @_URC_HANDLER_FOUND@; otherwise
 it return @_URC_CONTINUE_UNWIND@.
 …
 \end{cfa}
 It also unwinds the stack but it does not use the search phase. Instead another
 function, the stop function, is used to stop searching.  The exception is the
+function, the stop function, is used to stop searching. The exception is the
 same as the one passed to raise exception. The extra arguments are the stop
 function and the stop parameter. The stop function has a similar interface as a
 …
 \begin{sloppypar}
 Its arguments are the same as the paired personality function.  The actions
+Its arguments are the same as the paired personality function. The actions
 @_UA_CLEANUP_PHASE@ and @_UA_FORCE_UNWIND@ are always set when it is
 called. Beyond the libunwind standard, both GCC and Clang add an extra action
 …
 strong symbol replacing the sequential version.
+% The version of the function defined in @libcfa@ is very simple. It returns a
+% pointer to a global static variable. With only one stack this global instance
+% is associated with the only stack.
+For coroutines, @this_exception_context@ accesses the exception context stored
+at the base of the stack. For threads, @this_exception_context@ uses the
+concurrency library to access the current stack of the thread or coroutine
+being executed by the thread, and then accesses the exception context stored at
+the base of this stack.
+The sequential @this_exception_context@ returns a hard-coded pointer to the
+global execption context.
+The concurrent version adds the exception context to the data stored at the
+base of each stack. When @this_exception_context@ is called it retrieves the
+active stack and returns the address of the context saved there.
 \section{Termination}
 …
 per-exception storage.
+Exceptions are stored in variable-sized blocks. \PAB{Show a memory layout
+figure.} The first component is a fixed sized data structure that contains the
+[Quick ASCII diagram to get started.]
+\begin{verbatim}
+Fixed Header  | _Unwind_Exception   <- pointer target
+              |
+              | Cforall storage
+              |
+Variable Body | the exception       <- fixed offset
+              V ...
+\end{verbatim}
+Exceptions are stored in variable-sized blocks.
+The first component is a fixed sized data structure that contains the
 information for libunwind and the exception system. The second component is an
 area of memory big enough to store the exception. Macros with pointer arthritic
 …
 exception type. The size and copy function are used immediately to copy an
 exception into managed memory. After the exception is handled the free function
+is used to clean up the exception and then the entire node is passed to free.
+is used to clean up the exception and then the entire node is passed to free
+so the memory can be given back to the heap.
 \subsection{Try Statements and Catch Clauses}
 …
 library. The contents of a try block and the termination handlers are converted
 into functions. These are then passed to the try terminate function and it
+calls them. This approach puts a try statement in its own functions so that no
+function has to deal with both termination handlers and destructors. \PAB{I do
+not understand the previous sentence.}
+This function has some custom embedded assembly that defines \emph{its}
+personality function and LSDA. The assembly is created with handcrafted C @asm@
+statements, which is why there is only one version of it. The personality
+function is structured so that it can be expanded, but currently it only
+handles this one function.  Notably, it does not handle any destructors so the
+function is constructed so that it does need to run it. \PAB{I do not
+understand the previous sentence.}
+calls them.
+Because this function is known and fixed (and not an arbitrary function that
+happens to contain a try statement) this means the LSDA can be generated ahead
+of time.
+Both the LSDA and the personality function are set ahead of time using
+embedded assembly. This is handcrafted using C @asm@ statements and contains
+enough information for the single try statement the function repersents.
 The three functions passed to try terminate are:
 …
 \item[match function:] This function is called during the search phase and
 decides if a catch clause matches the termination exception.  It is constructed
+decides if a catch clause matches the termination exception. It is constructed
 from the conditional part of each handler and runs each check, top to bottom,
 in turn, first checking to see if the exception type matches and then if the
 …
 \item[handler function:] This function handles the exception. It takes a
 pointer to the exception and the handler's id and returns nothing. It is called
 after the cleanup phase.  It is constructed by stitching together the bodies of
+after the cleanup phase. It is constructed by stitching together the bodies of
 each handler and dispatches to the selected handler.
 \end{description}
 …
 can be used to create closures, functions that can refer to the state of other
 functions on the stack. This approach allows the functions to refer to all the
 variables in scope for the function containing the @try@ statement.  These
+variables in scope for the function containing the @try@ statement. These
 nested functions and all other functions besides @__cfaehm_try_terminate@ in
 \CFA use the GCC personality function and the @-fexceptions@ flag to generate
 …
 handler that matches. If no handler matches then the function returns
 false. Otherwise the matching handler is run; if it completes successfully, the
 function returns true. Reresume, through the @throwResume;@ statement, cause
 the function to return true.
+function returns true. Rethrowing, through the @throwResume;@ statement,
+causes the function to return true.
 % Recursive Resumption Stuff:
 …
 providing zero-cost enter/exit using the LSDA. Unfortunately, there is no way
 to return from a libunwind search without installing a handler or raising an
 error.  Although workarounds might be possible, they are beyond the scope of
+error. Although workarounds might be possible, they are beyond the scope of
 this thesis. The current resumption implementation has simplicity in its
 favour.
 …
 Cancellation also uses libunwind to do its stack traversal and unwinding,
 however it uses a different primary function @_Unwind_ForcedUnwind@.  Details
+however it uses a different primary function @_Unwind_ForcedUnwind@. Details
 of its interface can be found in the \VRef{s:ForcedUnwind}.
 …
 its main coroutine and the coroutine it is currently executing.
+The first check is if the current thread's main and current coroutine do not
+match, implying a coroutine cancellation; otherwise, it is a thread
+cancellation. Otherwise it is a main thread cancellation. \PAB{Previous
+sentence does not make sense.}
+So if the active thread's main and current coroutine are the same. If they
+are then the current stack is a thread stack, otherwise it is a coroutine
+stack. If it is a thread stack then an equality check with the stored main
+thread pointer and current thread pointer is enough to tell if the current
+thread is the main thread or not.
 However, if the threading library is not linked, the sequential execution is on

doc/theses/andrew_beach_MMath/uw-ethesis.tex

-              rfeacef9
+              r5407cdc
 % ======================================================================
 %   D O C U M E N T   P R E A M B L E
+% Specify the document class, default style attributes, page dimensions, etc.
+% For hyperlinked PDF, suitable for viewing on a computer, use this:
+\documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
+% For PDF, suitable for double-sided printing, change the PrintVersion
+% variable below to "true" and use this \documentclass line instead of the
+% one above:
+%\documentclass[letterpaper,12pt,titlepage,openright,twoside,final]{book}
+\usepackage{etoolbox}
+\RequirePackage{etoolbox}
+% Control if this for print (set true) or will stay digital (default).
+% Print is two sided, digital uses more colours.
+\newtoggle{printversion}
+%\toggletrue{printversion}
+\iftoggle{printversion}{%
+  \documentclass[letterpaper,12pt,titlepage,openright,twoside,final]{book}
+}{%
+  \documentclass[letterpaper,12pt,titlepage,oneside,final]{book}
+}
 % Some LaTeX commands I define for my own nomenclature.
 …
 % Anything defined here may be redefined by packages added below...
+% This package allows if-then-else control structures.
+\usepackage{ifthen}
+\newboolean{PrintVersion}
+\setboolean{PrintVersion}{false}
+% CHANGE THIS VALUE TO "true" as necessary, to improve printed results for
+% hard copies by overriding some options of the hyperref package, called below.
+%\usepackage{nomencl} % For a nomenclature (optional; available from ctan.org)
+% For a nomenclature (optional; available from ctan.org)
+%\usepackage{nomencl}
 % Lots of math symbols and environments
 \usepackage{amsmath,amssymb,amstext}
+% For including graphics N.B. pdftex graphics driver
+\usepackage[pdftex]{graphicx}
+% For including graphics (must match graphics driver)
+\usepackage{epic,eepic}
+\usepackage{graphicx}
 % Removes large sections of the document.
 \usepackage{comment}
 % Adds todos (Must be included after comment.)
 \usepackage{todonotes}
 % Hyperlinks make it very easy to navigate an electronic document.
 …
 % Use the "hyperref" package
 % N.B. HYPERREF MUST BE THE LAST PACKAGE LOADED; ADD ADDITIONAL PKGS ABOVE
+\usepackage[pdftex,pagebackref=true]{hyperref} % with basic options
+%\usepackage[pdftex,pagebackref=true]{hyperref}
+\usepackage[pagebackref=true]{hyperref}
 % N.B. pagebackref=true provides links back from the References to the body
 % text. This can cause trouble for printing.
 …
     pdffitwindow=false,     % window fit to page when opened
     pdfstartview={FitH},    % fits the width of the page to the window
-%    pdftitle={uWaterloo\ LaTeX\ Thesis\ Template}, % title: CHANGE THIS TEXT!
-%    pdfauthor={Author},    % author: CHANGE THIS TEXT! and uncomment this line
-%    pdfsubject={Subject},  % subject: CHANGE THIS TEXT! and uncomment this line
-%    pdfkeywords={keyword1} {key2} {key3}, % optional list of keywords
     pdfnewwindow=true,      % links in new window
     colorlinks=true,        % false: boxed links; true: colored links
-    linkcolor=blue,         % color of internal links
-    citecolor=green,        % color of links to bibliography
-    filecolor=magenta,      % color of file links
-    urlcolor=cyan           % color of external links
+}
+% for improved print quality, change some hyperref options
+\ifthenelse{\boolean{PrintVersion}}{
+\hypersetup{    % override some previously defined hyperref options
+%    colorlinks,%
+    citecolor=black,%
+    filecolor=black,%
+    linkcolor=black,%
+    urlcolor=black}
+}{} % end of ifthenelse (no else)
+\iftoggle{printversion}{
+  \hypersetup{
+    citecolor=black,        % colour of links to bibliography
+    filecolor=black,        % colour of file links
+    linkcolor=black,        % colour of internal links
+    urlcolor=black,         % colour of external links
+  }
+}{ % Digital Version
+  \hypersetup{
+    citecolor=green,
+    filecolor=magenta,
+    linkcolor=blue,
+    urlcolor=cyan,
+  }
+}
+\hypersetup{
+  pdftitle={Exception Handling in Cforall},
+  pdfauthor={Andrew James Beach},
+  pdfsubject={Computer Science},
+  pdfkeywords={programming languages} {exceptions}
+      {language design} {language implementation},
+}
 % Exception to the rule of hyperref being the last add-on package
 …
 \pdfstringdefDisableCommands{\def\Cpp{C++}}
+% Wrappers for inline code snippits.
+\newrobustcmd*\codeCFA[1]{\lstinline[language=CFA]{#1}}
+\newrobustcmd*\codeC[1]{\lstinline[language=C]{#1}}
+\newrobustcmd*\codeCpp[1]{\lstinline[language=C++]{#1}}
+\newrobustcmd*\codePy[1]{\lstinline[language=Python]{#1}}
 % Colour text, formatted in LaTeX style instead of TeX style.
 \newcommand*\colour[2]{{\color{#1}#2}}

doc/theses/thierry_delisle_PhD/code/readyQ_proto/links.hpp

rfeacef9	r5407cdc
117	117	}
118	118
119		long long ts() const {
	119	unsigned long long ts() const {
120	120	return before._links.ts;
121	121	}

doc/theses/thierry_delisle_PhD/code/readyQ_proto/processor_list.hpp

-              rfeacef9
+              r5407cdc
                 while( __builtin_expect(ll.exchange(true),false) ) {
                         while(ll.load(std::memory_order_relaxed))
                                 asm volatile("pause");
+                                Pause();
+                }
                 /* paranoid */ assert(ll);
 …
                          && ready.compare_exchange_weak(copy, n + 1) )
                                 break;
                         asm volatile("pause");
+                        Pause();
+                }
 …
                 // Step 1 : make sure no writer are in the middle of the critical section
                 while(lock.load(std::memory_order_relaxed))
                         asm volatile("pause");
+                        Pause();
                 // Fence needed because we don't want to start trying to acquire the lock
 …
                 //   to simply lock their own lock and enter.
                 while(lock.load(std::memory_order_relaxed))
                         asm volatile("pause");
+                        Pause();
                 // Step 2 : lock per-proc lock
 …
                 for(uint_fast32_t i = 0; i < s; i++) {
                         while(data[i].lock.load(std::memory_order_relaxed))
                                 asm volatile("pause");
+                                Pause();
+                }

doc/theses/thierry_delisle_PhD/code/readyQ_proto/processor_list_good.cpp

rfeacef9	r5407cdc
21	21	target = (target - (target % total)) + total;
22	22	while(waiting < target)
23		~~asm volatile("pause"~~);
	23	Pause();
24	24
25	25	assert(waiting < (1ul << 60));

doc/theses/thierry_delisle_PhD/code/readyQ_proto/randbit.cpp

rfeacef9	r5407cdc
123	123	target = (target - (target % total)) + total;
124	124	while(waiting < target)
125		~~asm volatile("pause"~~);
	125	Pause();
126	126
127	127	assert(waiting < (1ul << 60));

doc/theses/thierry_delisle_PhD/code/readyQ_proto/relaxed_list.cpp

-              rfeacef9
+              r5407cdc
         std::cout << "Total ops     : " << ops << "(" << global.in << "i, " << global.out << "o, " << global.empty << "e)\n";
         #ifndef NO_STATS
                 LIST_VARIANT<Node>::stats_print(std::cout);
+                LIST_VARIANT<Node>::stats_print(std::cout, duration);
         #endif
+}
 …
                 for(Node * & node : nodes) {
+                        node = list.pop();
+                        assert(node);
+                        node = nullptr;
+                        while(!node) {
+                                node = list.pop();
+                        }
                         local.crc_out += node->value;
                         local.out++;
 …
                                 for(const auto & n : nodes) {
                                         local.valmax = max(local.valmax, size_t(n.value));
                                         local.valmin = min(local.valmin, size_t(n.value));
+                                        local.valmax = std::max(local.valmax, size_t(n.value));
+                                        local.valmin = std::min(local.valmin, size_t(n.value));
+                                }
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                         nslots = nnodes;
 …
                                                 try {
                                                         arg = optarg = argv[optind];
                                                         nnodes = stoul(optarg, &len);
+                                                        nnodes = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                                                 try {
                                                         arg = optarg = argv[optind + 1];
                                                         nslots = stoul(optarg, &len);
+                                                        nslots = std::stoul(optarg, &len);
                                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                                 } catch(std::invalid_argument &) {
 …
                         case 'd':
                                 try {
                                         duration = stod(optarg, &len);
+                                        duration = std::stod(optarg, &len);
                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                 } catch(std::invalid_argument &) {
 …
                         case 't':
                                 try {
                                         nthreads = stoul(optarg, &len);
+                                        nthreads = std::stoul(optarg, &len);
                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                 } catch(std::invalid_argument &) {
 …
                         case 'q':
                                 try {
                                         nqueues = stoul(optarg, &len);
+                                        nqueues = std::stoul(optarg, &len);
                                         if(len != arg.size()) { throw std::invalid_argument(""); }
                                 } catch(std::invalid_argument &) {

doc/theses/thierry_delisle_PhD/code/readyQ_proto/snzi-packed.hpp

-              rfeacef9
+              r5407cdc
         for(int i = 0; i < width; i++) {
                 int idx = i % hwdith;
-                std::cout << i << " -> " << idx + width << std::endl;
                 leafs[i].parent = &nodes[ idx ];
+        }
 …
         for(int i = 0; i < root; i++) {
                 int idx = (i / 2) + hwdith;
-                std::cout << i + width << " -> " << idx + width << std::endl;
                 nodes[i].parent = &nodes[ idx ];
+        }

doc/theses/thierry_delisle_PhD/code/readyQ_proto/snzi.hpp

rfeacef9	r5407cdc
159	159	std::cout << "SNZI: " << depth << "x" << width << "(" << mask - 1 << ") " << (sizeof(snzi_t::node) * (root + 1)) << " bytes" << std::endl;
160	160	for(int i = 0; i < root; i++) {
161		~~std::cout << i << " -> " << (i / base) + width << std::endl;~~
162	161	nodes[i].parent = &nodes[(i / base) + width];
163	162	}

doc/theses/thierry_delisle_PhD/code/readyQ_proto/utils.hpp

-              rfeacef9
+              r5407cdc
 #include <sys/sysinfo.h>
+#include <x86intrin.h>
+// Barrier from
+class barrier_t {
+public:
+        barrier_t(size_t total)
+                : waiting(0)
+                , total(total)
+        {}
+        void wait(unsigned) {
+                size_t target = waiting++;
+                target = (target - (target % total)) + total;
+                while(waiting < target)
+                        asm volatile("pause");
+                assert(waiting < (1ul << 60));
+        }
+private:
+        std::atomic<size_t> waiting;
+        size_t total;
+};
+// #include <x86intrin.h>
 // class Random {
 …
 };
+static inline long long rdtscl(void) {
+    unsigned int lo, hi;
+    __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+    return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+}
+static inline long long int rdtscl(void) {
+        #if defined( __i386 ) || defined( __x86_64 )
+                unsigned int lo, hi;
+                __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+                return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+        #elif defined( __aarch64__ ) || defined( __arm__ )
+                // https://github.com/google/benchmark/blob/v1.1.0/src/cycleclock.h#L116
+                long long int virtual_timer_value;
+                asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
+                return virtual_timer_value;
+        #else
+                #error unsupported hardware architecture
+        #endif
+}
+#if defined( __i386 ) || defined( __x86_64 )
+        #define Pause() __asm__ __volatile__ ( "pause" : : : )
+#elif defined( __ARM_ARCH )
+        #define Pause() __asm__ __volatile__ ( "YIELD" : : : )
+#else
+        #error unsupported architecture
+#endif
 static inline void affinity(int tid) {
 …
+}
+// Barrier from
+class barrier_t {
+public:
+        barrier_t(size_t total)
+                : waiting(0)
+                , total(total)
+        {}
+        void wait(unsigned) {
+                size_t target = waiting++;
+                target = (target - (target % total)) + total;
+                while(waiting < target)
+                        Pause();
+                assert(waiting < (1ul << 60));
+        }
+private:
+        std::atomic<size_t> waiting;
+        size_t total;
+};
 struct spinlock_t {
         std::atomic_bool ll = { false };
 …
                 while( __builtin_expect(ll.exchange(true),false) ) {
                         while(ll.load(std::memory_order_relaxed))
                                 asm volatile("pause");
+                                Pause();
+                }
+        }

doc/theses/thierry_delisle_PhD/code/readyQ_proto/work_stealing.hpp

-              rfeacef9
+              r5407cdc
 #include <memory>
 #include <mutex>
+#include <thread>
 #include <type_traits>
 …
 #include "utils.hpp"
 #include "links.hpp"
+#include "links2.hpp"
 #include "snzi.hpp"
+// #include <x86intrin.h>
 using namespace std;
+static const long long lim = 2000;
+static const unsigned nqueues = 2;
+struct __attribute__((aligned(128))) timestamp_t {
+        volatile unsigned long long val = 0;
+};
+template<typename node_t>
+struct __attribute__((aligned(128))) localQ_t {
+        #ifdef NO_MPSC
+                intrusive_queue_t<node_t> list;
+                inline auto ts() { return list.ts(); }
+                inline auto lock() { return list.lock.lock(); }
+                inline auto try_lock() { return list.lock.try_lock(); }
+                inline auto unlock() { return list.lock.unlock(); }
+                inline auto push( node_t * node ) { return list.push( node ); }
+                inline auto pop() { return list.pop(); }
+        #else
+                mpsc_queue<node_t> queue = {};
+                spinlock_t _lock = {};
+                inline auto ts() { auto h = queue.head(); return h ? h->_links.ts : 0ull; }
+                inline auto lock() { return _lock.lock(); }
+                inline auto try_lock() { return _lock.try_lock(); }
+                inline auto unlock() { return _lock.unlock(); }
+                inline auto push( node_t * node ) { return queue.push( node ); }
+                inline auto pop() { return queue.pop(); }
+        #endif
+};
 template<typename node_t>
 …
         work_stealing(unsigned _numThreads, unsigned)
+                : numThreads(_numThreads)
+                , lists(new intrusive_queue_t<node_t>[numThreads])
+                , snzi( std::log2( numThreads / 2 ), 2 )
+                : numThreads(_numThreads * nqueues)
+                , lists(new localQ_t<node_t>[numThreads])
+                // , lists(new intrusive_queue_t<node_t>[numThreads])
+                , times(new timestamp_t[numThreads])
+                // , snzi( std::log2( numThreads / 2 ), 2 )
+        {
 …
         __attribute__((noinline, hot)) void push(node_t * node) {
                 node->_links.ts = rdtscl();
+                if( node->_links.hint > numThreads ) {
+                        node->_links.hint = tls.rng.next() % numThreads;
+                        tls.stat.push.nhint++;
+                // node->_links.ts = 1;
+                auto & list = *({
+                        unsigned i;
+                        #ifdef NO_MPSC
+                                do {
+                        #endif
+                                tls.stats.push.attempt++;
+                                // unsigned r = tls.rng1.next();
+                                unsigned r = tls.it++;
+                                if(tls.my_queue == outside) {
+                                        i = r % numThreads;
+                                } else {
+                                        i = tls.my_queue + (r % nqueues);
+                                }
+                        #ifdef NO_MPSC
+                                } while(!lists[i].try_lock());
+                        #endif
+                        &lists[i];
+                });
+                list.push( node );
+                #ifdef NO_MPSC
+                        list.unlock();
+                #endif
+                // tls.rng2.set_raw_state( tls.rng1.get_raw_state());
+                // count++;
+                tls.stats.push.success++;
+        }
+        __attribute__((noinline, hot)) node_t * pop() {
+                if(tls.my_queue != outside) {
+                        // if( tls.myfriend == outside ) {
+                        //      auto r  = tls.rng1.next();
+                        //      tls.myfriend = r % numThreads;
+                        //      // assert(lists[(tls.it % nqueues) + tls.my_queue].ts() >= lists[((tls.it + 1) % nqueues) + tls.my_queue].ts());
+                        //      tls.mytime = std::min(lists[(tls.it % nqueues) + tls.my_queue].ts(), lists[((tls.it + 1) % nqueues) + tls.my_queue].ts());
+                        //      // times[tls.myfriend].val = 0;
+                        //      // lists[tls.myfriend].val = 0;
+                        // }
+                        // // else if(times[tls.myfriend].val == 0) {
+                        // // else if(lists[tls.myfriend].val == 0) {
+                        // else if(times[tls.myfriend].val < tls.mytime) {
+                        // // else if(times[tls.myfriend].val < lists[(tls.it % nqueues) + tls.my_queue].ts()) {
+                        //      node_t * n = try_pop(tls.myfriend, tls.stats.pop.help);
+                        //      tls.stats.help++;
+                        //      tls.myfriend = outside;
+                        //      if(n) return n;
+                        // }
+                        // if( tls.myfriend == outside ) {
+                        //      auto r  = tls.rng1.next();
+                        //      tls.myfriend = r % numThreads;
+                        //      tls.mytime = lists[((tls.it + 1) % nqueues) + tls.my_queue].ts();
+                        // }
+                        // else {
+                        //      if(times[tls.myfriend].val + 1000 < tls.mytime) {
+                        //              node_t * n = try_pop(tls.myfriend, tls.stats.pop.help);
+                        //              tls.stats.help++;
+                        //              if(n) return n;
+                        //      }
+                        //      tls.myfriend = outside;
+                        // }
+                        node_t * n = local();
+                        if(n) return n;
+                }
+                unsigned i = node->_links.hint;
+                auto & list = lists[i];
+                list.lock.lock();
+                if(list.push( node )) {
+                        snzi.arrive(i);
+                // try steal
+                for(int i = 0; i < 25; i++) {
+                        node_t * n = steal();
+                        if(n) return n;
+                }
+                list.lock.unlock();
+        }
+        __attribute__((noinline, hot)) node_t * pop() {
+                node_t * node;
+                while(true) {
+                        if(!snzi.query()) {
+                                return nullptr;
+                        }
+                        {
+                                unsigned i = tls.my_queue;
+                                auto & list = lists[i];
+                                if( list.ts() != 0 ) {
+                                        list.lock.lock();
+                                        if((node = try_pop(i))) {
+                                                tls.stat.pop.local.success++;
+                                                break;
+                                        }
+                                        else {
+                                                tls.stat.pop.local.elock++;
+                                        }
+                                }
+                                else {
+                                        tls.stat.pop.local.espec++;
+                                }
+                        }
+                        tls.stat.pop.steal.tried++;
+                        int i = tls.rng.next() % numThreads;
+                        auto & list = lists[i];
+                        if( list.ts() == 0 ) {
+                                tls.stat.pop.steal.empty++;
+                                continue;
+                        }
+                        if( !list.lock.try_lock() ) {
+                                tls.stat.pop.steal.locked++;
+                                continue;
+                        }
+                        if((node = try_pop(i))) {
+                                tls.stat.pop.steal.success++;
+                                break;
+                return search();
+        }
+private:
+        inline node_t * local() {
+                unsigned i = (--tls.it % nqueues) + tls.my_queue;
+                node_t * n = try_pop(i, tls.stats.pop.local);
+                if(n) return n;
+                i = (--tls.it % nqueues) + tls.my_queue;
+                return try_pop(i, tls.stats.pop.local);
+        }
+        inline node_t * steal() {
+                unsigned i = tls.rng2.prev() % numThreads;
+                return try_pop(i, tls.stats.pop.steal);
+        }
+        inline node_t * search() {
+                unsigned offset = tls.rng2.prev();
+                for(unsigned i = 0; i < numThreads; i++) {
+                        unsigned idx = (offset + i) % numThreads;
+                        node_t * thrd = try_pop(idx, tls.stats.pop.search);
+                        if(thrd) {
+                                return thrd;
+                        }
+                }
+                #if defined(READ)
+                        const unsigned f = READ;
+                        if(0 == (tls.it % f)) {
+                                unsigned i = tls.it / f;
+                                lists[i % numThreads].ts();
+                        }
+                        // lists[tls.it].ts();
+                        tls.it++;
+                #endif
+                return node;
+        }
+private:
+        node_t * try_pop(unsigned i) {
+                return nullptr;
+        }
+private:
+        struct attempt_stat_t {
+                std::size_t attempt = { 0 };
+                std::size_t elock   = { 0 };
+                std::size_t eempty  = { 0 };
+                std::size_t espec   = { 0 };
+                std::size_t success = { 0 };
+        };
+        node_t * try_pop(unsigned i, attempt_stat_t & stat) {
+                assert(i < numThreads);
                 auto & list = lists[i];
+                stat.attempt++;
+                // If the list is empty, don't try
+                if(list.ts() == 0) { stat.espec++; return nullptr; }
+                // If we can't get the lock, move on
+                if( !list.try_lock() ) { stat.elock++; return nullptr; }
                 // If list is empty, unlock and retry
                 if( list.ts() == 0 ) {
+                        list.lock.unlock();
+                        list.unlock();
+                        stat.eempty++;
                         return nullptr;
+                }
+                        // Actually pop the list
+                node_t * node;
+                bool emptied;
+                std::tie(node, emptied) = list.pop();
+                assert(node);
+                if(emptied) {
+                        snzi.depart(i);
+                }
+                // Unlock and return
+                list.lock.unlock();
+                return node;
+                auto node = list.pop();
+                list.unlock();
+                stat.success++;
+                #ifdef NO_MPSC
+                        // times[i].val = 1;
+                        times[i].val = node.first->_links.ts;
+                        // lists[i].val = node.first->_links.ts;
+                        return node.first;
+                #else
+                        times[i].val = node->_links.ts;
+                        return node;
+                #endif
+        }
 …
         static std::atomic_uint32_t ticket;
+        static const unsigned outside = 0xFFFFFFFF;
+        static inline unsigned calc_preferred() {
+                unsigned t = ticket++;
+                if(t == 0) return outside;
+                unsigned i = (t - 1) * nqueues;
+                return i;
+        }
         static __attribute__((aligned(128))) thread_local struct TLS {
+                Random     rng = { int(rdtscl()) };
+                unsigned   my_queue = ticket++;
+                Random     rng1 = { unsigned(std::hash<std::thread::id>{}(std::this_thread::get_id()) ^ rdtscl()) };
+                Random     rng2 = { unsigned(std::hash<std::thread::id>{}(std::this_thread::get_id()) ^ rdtscl()) };
+                unsigned   it   = 0;
+                unsigned   my_queue = calc_preferred();
+                unsigned   myfriend = outside;
+                unsigned long long int mytime = 0;
                 #if defined(READ)
                         unsigned it = 0;
 …
                 struct {
                         struct {
+                                std::size_t nhint = { 0 };
+                                std::size_t attempt = { 0 };
+                                std::size_t success = { 0 };
                         } push;
                         struct {
+                                struct {
+                                        std::size_t success = { 0 };
+                                        std::size_t espec = { 0 };
+                                        std::size_t elock = { 0 };
+                                } local;
+                                struct {
+                                        std::size_t tried   = { 0 };
+                                        std::size_t locked  = { 0 };
+                                        std::size_t empty   = { 0 };
+                                        std::size_t success = { 0 };
+                                } steal;
+                                attempt_stat_t help;
+                                attempt_stat_t local;
+                                attempt_stat_t steal;
+                                attempt_stat_t search;
                         } pop;
+                } stat;
+                        std::size_t help = { 0 };
+                } stats;
         } tls;
 private:
         const unsigned numThreads;
+        std::unique_ptr<intrusive_queue_t<node_t> []> lists;
+        __attribute__((aligned(64))) snzi_t snzi;
+        std::unique_ptr<localQ_t<node_t> []> lists;
+        // std::unique_ptr<intrusive_queue_t<node_t> []> lists;
+        std::unique_ptr<timestamp_t []> times;
+        __attribute__((aligned(128))) std::atomic_size_t count;
 #ifndef NO_STATS
 …
         static struct GlobalStats {
                 struct {
+                        std::atomic_size_t nhint = { 0 };
+                        std::atomic_size_t attempt = { 0 };
+                        std::atomic_size_t success = { 0 };
                 } push;
                 struct {
                         struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
                                 std::atomic_size_t success = { 0 };
+                                std::atomic_size_t espec = { 0 };
+                                std::atomic_size_t elock = { 0 };
+                        } help;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
+                                std::atomic_size_t success = { 0 };
                         } local;
                         struct {
+                                std::atomic_size_t tried   = { 0 };
+                                std::atomic_size_t locked  = { 0 };
+                                std::atomic_size_t empty   = { 0 };
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
                                 std::atomic_size_t success = { 0 };
                         } steal;
+                        struct {
+                                std::atomic_size_t attempt = { 0 };
+                                std::atomic_size_t elock   = { 0 };
+                                std::atomic_size_t eempty  = { 0 };
+                                std::atomic_size_t espec   = { 0 };
+                                std::atomic_size_t success = { 0 };
+                        } search;
                 } pop;
+                std::atomic_size_t help = { 0 };
         } global_stats;
 public:
         static void stats_tls_tally() {
+                global_stats.push.nhint += tls.stat.push.nhint;
+                global_stats.pop.local.success += tls.stat.pop.local.success;
+                global_stats.pop.local.espec   += tls.stat.pop.local.espec  ;
+                global_stats.pop.local.elock   += tls.stat.pop.local.elock  ;
+                global_stats.pop.steal.tried   += tls.stat.pop.steal.tried  ;
+                global_stats.pop.steal.locked  += tls.stat.pop.steal.locked ;
+                global_stats.pop.steal.empty   += tls.stat.pop.steal.empty  ;
+                global_stats.pop.steal.success += tls.stat.pop.steal.success;
+        }
+        static void stats_print(std::ostream & os ) {
+                global_stats.push.attempt += tls.stats.push.attempt;
+                global_stats.push.success += tls.stats.push.success;
+                global_stats.pop.help  .attempt += tls.stats.pop.help  .attempt;
+                global_stats.pop.help  .elock   += tls.stats.pop.help  .elock  ;
+                global_stats.pop.help  .eempty  += tls.stats.pop.help  .eempty ;
+                global_stats.pop.help  .espec   += tls.stats.pop.help  .espec  ;
+                global_stats.pop.help  .success += tls.stats.pop.help  .success;
+                global_stats.pop.local .attempt += tls.stats.pop.local .attempt;
+                global_stats.pop.local .elock   += tls.stats.pop.local .elock  ;
+                global_stats.pop.local .eempty  += tls.stats.pop.local .eempty ;
+                global_stats.pop.local .espec   += tls.stats.pop.local .espec  ;
+                global_stats.pop.local .success += tls.stats.pop.local .success;
+                global_stats.pop.steal .attempt += tls.stats.pop.steal .attempt;
+                global_stats.pop.steal .elock   += tls.stats.pop.steal .elock  ;
+                global_stats.pop.steal .eempty  += tls.stats.pop.steal .eempty ;
+                global_stats.pop.steal .espec   += tls.stats.pop.steal .espec  ;
+                global_stats.pop.steal .success += tls.stats.pop.steal .success;
+                global_stats.pop.search.attempt += tls.stats.pop.search.attempt;
+                global_stats.pop.search.elock   += tls.stats.pop.search.elock  ;
+                global_stats.pop.search.eempty  += tls.stats.pop.search.eempty ;
+                global_stats.pop.search.espec   += tls.stats.pop.search.espec  ;
+                global_stats.pop.search.success += tls.stats.pop.search.success;
+                global_stats.help += tls.stats.help;
+        }
+        static void stats_print(std::ostream & os, double duration ) {
                 std::cout << "----- Work Stealing Stats -----" << std::endl;
+                double stealSucc = double(global_stats.pop.steal.success) / global_stats.pop.steal.tried;
+                os << "Push to new Q : " << std::setw(15) << global_stats.push.nhint << "\n";
+                os << "Local Pop     : " << std::setw(15) << global_stats.pop.local.success << "\n";
+                os << "Steal Pop     : " << std::setw(15) << global_stats.pop.steal.success << "(" << global_stats.pop.local.espec << "s, " << global_stats.pop.local.elock << "l)\n";
+                os << "Steal Success : " << std::setw(15) << stealSucc << "(" << global_stats.pop.steal.tried << " tries)\n";
+                os << "Steal Fails   : " << std::setw(15) << global_stats.pop.steal.empty << "e, " << global_stats.pop.steal.locked << "l\n";
+                double push_suc = (100.0 * double(global_stats.push.success) / global_stats.push.attempt);
+                double push_len = double(global_stats.push.attempt     ) / global_stats.push.success;
+                os << "Push   Pick : " << push_suc << " %, len " << push_len << " (" << global_stats.push.attempt      << " / " << global_stats.push.success << ")\n";
+                double hlp_suc = (100.0 * double(global_stats.pop.help.success) / global_stats.pop.help.attempt);
+                double hlp_len = double(global_stats.pop.help.attempt     ) / global_stats.pop.help.success;
+                os << "Help        : " << hlp_suc << " %, len " << hlp_len << " (" << global_stats.pop.help.attempt      << " / " << global_stats.pop.help.success << ")\n";
+                os << "Help Fail   : " << global_stats.pop.help.espec << "s, " << global_stats.pop.help.eempty << "e, " << global_stats.pop.help.elock << "l\n";
+                double pop_suc = (100.0 * double(global_stats.pop.local.success) / global_stats.pop.local.attempt);
+                double pop_len = double(global_stats.pop.local.attempt     ) / global_stats.pop.local.success;
+                os << "Local       : " << pop_suc << " %, len " << pop_len << " (" << global_stats.pop.local.attempt      << " / " << global_stats.pop.local.success << ")\n";
+                os << "Local Fail  : " << global_stats.pop.local.espec << "s, " << global_stats.pop.local.eempty << "e, " << global_stats.pop.local.elock << "l\n";
+                double stl_suc = (100.0 * double(global_stats.pop.steal.success) / global_stats.pop.steal.attempt);
+                double stl_len = double(global_stats.pop.steal.attempt     ) / global_stats.pop.steal.success;
+                os << "Steal       : " << stl_suc << " %, len " << stl_len << " (" << global_stats.pop.steal.attempt      << " / " << global_stats.pop.steal.success << ")\n";
+                os << "Steal Fail  : " << global_stats.pop.steal.espec << "s, " << global_stats.pop.steal.eempty << "e, " << global_stats.pop.steal.elock << "l\n";
+                double srh_suc = (100.0 * double(global_stats.pop.search.success) / global_stats.pop.search.attempt);
+                double srh_len = double(global_stats.pop.search.attempt     ) / global_stats.pop.search.success;
+                os << "Search      : " << srh_suc << " %, len " << srh_len << " (" << global_stats.pop.search.attempt      << " / " << global_stats.pop.search.success << ")\n";
+                os << "Search Fail : " << global_stats.pop.search.espec << "s, " << global_stats.pop.search.eempty << "e, " << global_stats.pop.search.elock << "l\n";
+                os << "Helps       : " << std::setw(15) << std::scientific << global_stats.help / duration << "/sec (" << global_stats.help  << ")\n";
+        }
 private:

doc/user/figures/Cdecl.fig

-              rfeacef9
+              r5407cdc
 #FIG 3.2  Produced by xfig version 3.2.5b
+#FIG 3.2  Produced by xfig version 3.2.7b
 Landscape
 Center
 Inches
 Letter
+Letter
 .00
 Single
 …
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 1200 3600 1200 3600 1350 2850 1350 2850 1200
 1 0 50 -1 4 11 0.0000 2 120 90 2925 1325 0\001
 1 0 50 -1 4 11 0.0000 2 120 90 3075 1325 1\001
 1 0 50 -1 4 11 0.0000 2 120 90 3225 1325 2\001
 1 0 50 -1 4 11 0.0000 2 120 90 3375 1325 3\001
 1 0 50 -1 4 11 0.0000 2 120 90 3525 1325 4\001
+1 0 50 -1 4 11 0.0000 2 120 105 3075 1335 1\001
+1 0 50 -1 4 11 0.0000 2 120 105 3225 1335 2\001
+1 0 50 -1 4 11 0.0000 2 120 105 3375 1335 3\001
+1 0 50 -1 4 11 0.0000 2 120 105 3525 1335 4\001
+1 0 50 -1 4 11 0.0000 2 120 105 2925 1335 0\001
 -6
 2 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 5
 …
 1 1.00 45.00 60.00
 1275 2850 1275
 1 0 50 -1 4 11 0.0000 2 120 90 1350 1650 0\001
 1 0 50 -1 4 11 0.0000 2 120 90 1500 1650 1\001
 1 0 50 -1 4 11 0.0000 2 120 90 1650 1650 2\001
 1 0 50 -1 4 11 0.0000 2 120 90 1800 1650 3\001
 1 0 50 -1 4 11 0.0000 2 120 90 1950 1650 4\001
+1 0 50 -1 4 11 0.0000 2 120 105 1350 1650 0\001
+1 0 50 -1 4 11 0.0000 2 120 105 1500 1650 1\001
+1 0 50 -1 4 11 0.0000 2 120 105 1650 1650 2\001
+1 0 50 -1 4 11 0.0000 2 120 105 1800 1650 3\001
+1 0 50 -1 4 11 0.0000 2 120 105 1950 1650 4\001
 1 0 50 -1 4 11 0.0000 2 90 90 1200 1325 x\001
 1 0 50 -1 4 11 0.0000 2 90 90 2400 1325 x\001

doc/user/user.tex

-              rfeacef9
+              r5407cdc
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon Feb 15 13:48:53 2021
 %% Update Count     : 4452
+%% Last Modified On : Sun Apr 25 19:03:03 2021
+%% Update Count     : 4951
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 % math escape $...$ (dollar symbol)
 \input{common}                                          % common CFA document macros
+\setlength{\gcolumnposn}{3in}
 \CFAStyle                                                                                               % use default CFA format-style
 \lstset{language=CFA}                                                                   % CFA default lnaguage
 \lstnewenvironment{C++}[1][]                            % use C++ style
 {\lstset{language=C++,moredelim=**[is][\protect\color{red}]{@}{@},#1}}
+{\lstset{language=C++,moredelim=**[is][\protect\color{red}]{®}{®},#1}}
 {}
 …
 \newcommand{\Textbf}[2][red]{{\color{#1}{\textbf{#2}}}}
 \newcommand{\Emph}[2][red]{{\color{#1}\textbf{\emph{#2}}}}
 \newcommand{\R}[1]{\Textbf{#1}}
 \newcommand{\RC}[1]{\Textbf{\LstBasicStyle{#1}}}
+\newcommand{\R}[1]{{\color{red}#1}}
+\newcommand{\RB}[1]{\Textbf{#1}}
 \newcommand{\B}[1]{{\Textbf[blue]{#1}}}
 \newcommand{\G}[1]{{\Textbf[OliveGreen]{#1}}}
 …
 int main( void ) {
         int x = 0, y = 1, z = 2;
         @printf( "%d %d %d\n", x, y, z );@
+        ®printf( "%d %d %d\n", x, y, z );®
+}
 \end{cfa}
 …
 int main( void ) {
         int x = 0, y = 1, z = 2;
         @sout | x | y | z;@$\indexc{sout}$
+        ®sout | x | y | z;®$\indexc{sout}$
+}
 \end{cfa}
 …
 int main() {
         int x = 0, y = 1, z = 2;
         @cout<<x<<" "<<y<<" "<<z<<endl;@
+        ®cout<<x<<" "<<y<<" "<<z<<endl;®
+}
 \end{cfa}
 …
 \begin{tabular}{@{}rcccccccc@{}}
                 & 2021  & 2016  & 2011  & 2006  & 2001  & 1996  & 1991  & 1986  \\ \hline
 \R{C}   & \R{1} & \R{2} & \R{2} & \R{1} & \R{1} & \R{1} & \R{1} & \R{1} \\
+\RB{C}  & \RB{1}& \RB{2}& \RB{2}& \RB{1}& \RB{1}& \RB{1}& \RB{1}& \RB{1}\\
 Java    & 2             & 1             & 1             & 2             & 3             & 28    & -             & -             \\
 Python  & 3             & 5             & 6             & 7             & 23    & 13    & -             & -             \\
 …
 The signature feature of \CFA is \emph{\Index{overload}able} \Index{parametric-polymorphic} functions~\cite{forceone:impl,Cormack90,Duggan96} with functions generalized using a ©forall© clause (giving the language its name):
 \begin{cfa}
 @forall( otype T )@ T identity( T val ) { return val; }
+®forall( otype T )® T identity( T val ) { return val; }
 int forty_two = identity( 42 ); $\C{// T is bound to int, forty\_two == 42}$
 \end{cfa}
 …
 Whereas, \CFA wraps each of these routines into one overloaded name ©abs©:
 \begin{cfa}
 char @abs@( char );
 extern "C" { int @abs@( int ); } $\C{// use default C routine for int}$
 long int @abs@( long int );
 long long int @abs@( long long int );
 float @abs@( float );
 double @abs@( double );
 long double @abs@( long double );
 float _Complex @abs@( float _Complex );
 double _Complex @abs@( double _Complex );
 long double _Complex @abs@( long double _Complex );
+char ®abs®( char );
+extern "C" { int ®abs®( int ); } $\C{// use default C routine for int}$
+long int ®abs®( long int );
+long long int ®abs®( long long int );
+float ®abs®( float );
+double ®abs®( double );
+long double ®abs®( long double );
+float _Complex ®abs®( float _Complex );
+double _Complex ®abs®( double _Complex );
+long double _Complex ®abs®( long double _Complex );
 \end{cfa}
 The problem is \Index{name clash} between the C name ©abs© and the \CFA names ©abs©, resulting in two name linkages\index{C linkage}: ©extern "C"© and ©extern "Cforall"© (default).
 …
 The 2011 C standard plus GNU extensions.
 \item
 \Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]$-fgnu89-inline$}}
+\Indexc[deletekeywords=inline]{-fgnu89-inline}\index{compilation option!-fgnu89-inline@{\lstinline[deletekeywords=inline]{-fgnu89-inline}}}
 Use the traditional GNU semantics for inline routines in C11 mode, which allows inline routines in header files.
 \end{description}
 …
 Keyword clashes are accommodated by syntactic transformations using the \CFA backquote escape-mechanism:
 \begin{cfa}
 int @``@otype = 3; $\C{// make keyword an identifier}$
 double @``@forall = 3.5;
+int ®``®otype = 3; $\C{// make keyword an identifier}$
+double ®``®forall = 3.5;
 \end{cfa}
 …
 // include file uses the CFA keyword "with".
 #if ! defined( with )                                                   $\C{// nesting ?}$
 #define with @``@with                                                   $\C{// make keyword an identifier}$
+#define with ®``®with                                                   $\C{// make keyword an identifier}$
 #define __CFA_BFD_H__
 #endif
 …
 Numeric constants are extended to allow \Index{underscore}s\index{constant!underscore} as a separator, \eg:
 \begin{cfa}
 @_@147@_@483@_@648; $\C{// decimal constant}$
 @_@ul; $\C{// decimal unsigned long constant}$
 @_@377; $\C{// octal constant}$
 x@_@ff@_@ff; $\C{// hexadecimal constant}$
 x@_@ef3d@_@aa5c; $\C{// hexadecimal constant}$
 .141@_@592@_@654; $\C{// floating constant}$
 @_@e@_@+1@_@00; $\C{// floating constant}$
 x@_@ff@_@ff@_@p@_@3; $\C{// hexadecimal floating}$
 x@_@1.ffff@_@ffff@_@p@_@128@_@l; $\C{// hexadecimal floating long constant}$
 L@_@$"\texttt{\textbackslash{x}}$@_@$\texttt{ff}$@_@$\texttt{ee}"$; $\C{// wide character constant}$
+®_®147®_®483®_®648; $\C{// decimal constant}$
+®_®ul; $\C{// decimal unsigned long constant}$
+®_®377; $\C{// octal constant}$
+x®_®ff®_®ff; $\C{// hexadecimal constant}$
+x®_®ef3d®_®aa5c; $\C{// hexadecimal constant}$
+.141®_®592®_®654; $\C{// floating constant}$
+®_®e®_®+1®_®00; $\C{// floating constant}$
+x®_®ff®_®ff®_®p®_®3; $\C{// hexadecimal floating}$
+x®_®1.ffff®_®ffff®_®p®_®128®_®l; $\C{// hexadecimal floating long constant}$
+L®_®$"\texttt{\textbackslash{x}}$®_®$\texttt{ff}$®_®$\texttt{ee}"$; $\C{// wide character constant}$
 \end{cfa}
 The rules for placement of underscores are:
 …
 Floating exponentiation\index{exponentiation!floating} is performed using \Index{logarithm}s\index{exponentiation!logarithm}, so the exponent cannot be negative.
 \begin{cfa}
 sout | 1 @\@ 0 | 1 @\@ 1 | 2 @\@ 8 | -4 @\@ 3 | 5 @\@ 3 | 5 @\@ 32 | 5L @\@ 32 | 5L @\@ 64 | -4 @\@ -3 | -4.0 @\@ -3 | 4.0 @\@ 2.1
            | (1.0f+2.0fi) @\@ (3.0f+2.0fi);
 1 256 -64 125 @0@ 3273344365508751233 @0@ @0@ -0.015625 18.3791736799526 0.264715-1.1922i
+sout | 1 ®\® 0 | 1 ®\® 1 | 2 ®\® 8 | -4 ®\® 3 | 5 ®\® 3 | 5 ®\® 32 | 5L ®\® 32 | 5L ®\® 64 | -4 ®\® -3 | -4.0 ®\® -3 | 4.0 ®\® 2.1
+           | (1.0f+2.0fi) ®\® (3.0f+2.0fi);
+1 256 -64 125 ®0® 3273344365508751233 ®0® ®0® -0.015625 18.3791736799526 0.264715-1.1922i
 \end{cfa}
 Note, ©5 \ 32© and ©5L \ 64© overflow, and ©-4 \ -3© is a fraction but stored in an integer so all three computations generate an integral zero.
 …
 \begin{cfa}
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
 T ?@\@?( T ep, unsigned int y );
+T ?®\®?( T ep, unsigned int y );
 forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
 T ?@\@?( T ep, unsigned long int y );
+T ?®\®?( T ep, unsigned long int y );
 \end{cfa}
 The user type ©T© must define multiplication, one (©1©), and ©*©.
 …
 %\subsection{\texorpdfstring{\protect\lstinline@if@/\protect\lstinline@while@ Statement}{if Statement}}
+%\subsection{\texorpdfstring{\protect\lstinline{if}/\protect\lstinline{while} Statement}{if Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{if} / \LstKeywordStyle{while} Statement}{if / while Statement}}
 …
 Declarations in the ©do©-©while© condition are not useful because they appear after the loop body.}
 \begin{cfa}
 if ( @int x = f()@ ) ... $\C{// x != 0}$
 if ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
 if ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
 if ( @struct S { int i; } x = { f() }; x.i < 4@ ) $\C{// relational expression}$
 while ( @int x = f()@ ) ... $\C{// x != 0}$
 while ( @int x = f(), y = g()@ ) ... $\C{// x != 0 \&\& y != 0}$
 while ( @int x = f(), y = g(); x < y@ ) ... $\C{// relational expression}$
 while ( @struct S { int i; } x = { f() }; x.i < 4@ ) ... $\C{// relational expression}$
+if ( ®int x = f()® ) ... $\C{// x != 0}$
+if ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
+if ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
+if ( ®struct S { int i; } x = { f() }; x.i < 4® ) $\C{// relational expression}$
+while ( ®int x = f()® ) ... $\C{// x != 0}$
+while ( ®int x = f(), y = g()® ) ... $\C{// x != 0 \&\& y != 0}$
+while ( ®int x = f(), y = g(); x < y® ) ... $\C{// relational expression}$
+while ( ®struct S { int i; } x = { f() }; x.i < 4® ) ... $\C{// relational expression}$
 \end{cfa}
 Unless a relational expression is specified, each variable is compared not equal to 0, which is the standard semantics for the ©if©/©while© expression, and the results are combined using the logical ©&&© operator.
 …
 %\section{\texorpdfstring{\protect\lstinline@case@ Clause}{case Clause}}
+%\section{\texorpdfstring{\protect\lstinline{case} Clause}{case Clause}}
 \subsection{\texorpdfstring{\LstKeywordStyle{case} Clause}{case Clause}}
 \label{s:caseClause}
 …
 \begin{cfa}
 switch ( i ) {
   case @1, 3, 5@:
+  case ®1, 3, 5®:
         ...
   case @2, 4, 6@:
+  case ®2, 4, 6®:
         ...
+}
 …
 \end{cquote}
 In addition, subranges are allowed to specify case values.\footnote{
 gcc has the same mechanism but awkward syntax, \lstinline@2 ...42@, because a space is required after a number, otherwise the period is a decimal point.}
+gcc has the same mechanism but awkward syntax, \lstinline{2 ...42}, because a space is required after a number, otherwise the period is a decimal point.}
 \begin{cfa}
 switch ( i ) {
   case @1~5:@ $\C{// 1, 2, 3, 4, 5}$
+  case ®1~5:® $\C{// 1, 2, 3, 4, 5}$
         ...
   case @10~15:@ $\C{// 10, 11, 12, 13, 14, 15}$
+  case ®10~15:® $\C{// 10, 11, 12, 13, 14, 15}$
         ...
+}
 …
 Lists of subranges are also allowed.
 \begin{cfa}
 case @1~5, 12~21, 35~42@:
 \end{cfa}
 %\section{\texorpdfstring{\protect\lstinline@switch@ Statement}{switch Statement}}
+case ®1~5, 12~21, 35~42®:
+\end{cfa}
+%\section{\texorpdfstring{\protect\lstinline{switch} Statement}{switch Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{switch} Statement}{switch Statement}}
 …
 if ( argc == 3 ) {
         // open output file
         @// open input file
 @} else if ( argc == 2 ) {
         @// open input file (duplicate)
 @} else {
+        ®// open input file
+®} else if ( argc == 2 ) {
+        ®// open input file (duplicate)
+®} else {
         // usage message
+}
 …
 \begin{cfa}
 switch ( i ) {
   @case 1: case 3: case 5:@     // odd values
+  ®case 1: case 3: case 5:®     // odd values
         // odd action
         break;
   @case 2: case 4: case 6:@     // even values
+  ®case 2: case 4: case 6:®     // even values
         // even action
         break;
 …
         if ( j < k ) {
                 ...
           @case 1:@             // transfer into "if" statement
+          ®case 1:®             // transfer into "if" statement
                 ...
         } // if
 …
         while ( j < 5 ) {
                 ...
           @case 3:@             // transfer into "while" statement
+          ®case 3:®             // transfer into "while" statement
                 ...
         } // while
 …
 \begin{cfa}
 switch ( x ) {
         @int y = 1;@ $\C{// unreachable initialization}$
         @x = 7;@ $\C{// unreachable code without label/branch}$
+        ®int y = 1;® $\C{// unreachable initialization}$
+        ®x = 7;® $\C{// unreachable code without label/branch}$
   case 0: ...
         ...
         @int z = 0;@ $\C{// unreachable initialization, cannot appear after case}$
+        ®int z = 0;® $\C{// unreachable initialization, cannot appear after case}$
         z = 2;
   case 1:
         @x = z;@ $\C{// without fall through, z is uninitialized}$
+        ®x = z;® $\C{// without fall through, z is uninitialized}$
+}
 \end{cfa}
 …
 Therefore, to preserve backwards compatibility, it is necessary to introduce a new kind of ©switch© statement, called ©choose©, with no implicit fall-through semantics and an explicit fall-through if the last statement of a case-clause ends with the new keyword ©fallthrough©/©fallthru©, \eg:
 \begin{cfa}
 @choose@ ( i ) {
+®choose® ( i ) {
   case 1:  case 2:  case 3:
         ...
         @// implicit end of switch (break)
   @case 5:
+        ®// implicit end of switch (break)
+  ®case 5:
         ...
         @fallthru@; $\C{// explicit fall through}$
+        ®fallthru®; $\C{// explicit fall through}$
   case 7:
         ...
         @break@ $\C{// explicit end of switch (redundant)}$
+        ®break® $\C{// explicit end of switch (redundant)}$
   default:
         j = 3;
 …
 \begin{cfa}
 switch ( x ) {
         @int i = 0;@ $\C{// allowed only at start}$
+        ®int i = 0;® $\C{// allowed only at start}$
   case 0:
         ...
         @int j = 0;@ $\C{// disallowed}$
+        ®int j = 0;® $\C{// disallowed}$
   case 1:
+        {
                 @int k = 0;@ $\C{// allowed at different nesting levels}$
+                ®int k = 0;® $\C{// allowed at different nesting levels}$
                 ...
           @case 2:@ $\C{// disallow case in nested statements}$
+          ®case 2:® $\C{// disallow case in nested statements}$
+        }
   ...
 …
   case 3:
         if ( ... ) {
                 ... @fallthru;@ // goto case 4
+                ... ®fallthru;® // goto case 4
         } else {
                 ...
 …
 choose ( ... ) {
   case 3:
         ... @fallthrough common;@
+        ... ®fallthrough common;®
   case 4:
         ... @fallthrough common;@
   @common:@ // below fallthrough
+        ... ®fallthrough common;®
+  ®common:® // below fallthrough
                           // at case-clause level
         ...     // common code for cases 3/4
 …
                 for ( ... ) {
                         // multi-level transfer
                         ... @fallthru common;@
+                        ... ®fallthru common;®
+                }
                 ...
+        }
         ...
   @common:@ // below fallthrough
+  ®common:® // below fallthrough
                           // at case-clause level
 \end{cfa}
 …
 \hline
 \begin{cfa}
 while @($\,$)@ { sout | "empty"; break; }
 do { sout | "empty"; break; } while @($\,$)@;
 for @($\,$)@ { sout | "empty"; break; }
 for ( @0@ ) { sout | "A"; } sout | "zero";
 for ( @1@ ) { sout | "A"; }
 for ( @10@ ) { sout | "A"; }
 for ( @= 10@ ) { sout | "A"; }
 for ( @1 ~= 10 ~ 2@ ) { sout | "B"; }
 for ( @10 -~= 1 ~ 2@ ) { sout | "C"; }
 for ( @0.5 ~ 5.5@ ) { sout | "D"; }
 for ( @5.5 -~ 0.5@ ) { sout | "E"; }
 for ( @i; 10@ ) { sout | i; }
 for ( @i; = 10@ ) { sout | i; }
 for ( @i; 1 ~= 10 ~ 2@ ) { sout | i; }
 for ( @i; 10 -~= 1 ~ 2@ ) { sout | i; }
 for ( @i; 0.5 ~ 5.5@ ) { sout | i; }
 for ( @i; 5.5 -~ 0.5@ ) { sout | i; }
 for ( @ui; 2u ~= 10u ~ 2u@ ) { sout | ui; }
 for ( @ui; 10u -~= 2u ~ 2u@ ) { sout | ui; }
+while ®($\,$)® { sout | "empty"; break; }
+do { sout | "empty"; break; } while ®($\,$)®;
+for ®($\,$)® { sout | "empty"; break; }
+for ( ®0® ) { sout | "A"; } sout | "zero";
+for ( ®1® ) { sout | "A"; }
+for ( ®10® ) { sout | "A"; }
+for ( ®= 10® ) { sout | "A"; }
+for ( ®1 ~= 10 ~ 2® ) { sout | "B"; }
+for ( ®10 -~= 1 ~ 2® ) { sout | "C"; }
+for ( ®0.5 ~ 5.5® ) { sout | "D"; }
+for ( ®5.5 -~ 0.5® ) { sout | "E"; }
+for ( ®i; 10® ) { sout | i; }
+for ( ®i; = 10® ) { sout | i; }
+for ( ®i; 1 ~= 10 ~ 2® ) { sout | i; }
+for ( ®i; 10 -~= 1 ~ 2® ) { sout | i; }
+for ( ®i; 0.5 ~ 5.5® ) { sout | i; }
+for ( ®i; 5.5 -~ 0.5® ) { sout | i; }
+for ( ®ui; 2u ~= 10u ~ 2u® ) { sout | ui; }
+for ( ®ui; 10u -~= 2u ~ 2u® ) { sout | ui; }
 enum { N = 10 };
 for ( @N@ ) { sout | "N"; }
 for ( @i; N@ ) { sout | i; }
 for ( @i; N -~ 0@ ) { sout | i; }
+for ( ®N® ) { sout | "N"; }
+for ( ®i; N® ) { sout | i; }
+for ( ®i; N -~ 0® ) { sout | i; }
 const int start = 3, comp = 10, inc = 2;
 for ( @i; start ~ comp ~ inc + 1@ ) { sout | i; }
 for ( i; 1 ~ $\R{@}$ ) { if ( i > 10 ) break; sout | i; }
 for ( i; 10 -~ $\R{@}$ ) { if ( i < 0 ) break; sout | i; }
 for ( i; 2 ~ $\R{@}$ ~ 2 ) { if ( i > 10 ) break; sout | i; }
 for ( i; 2.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
 for ( i; 10 -~ $\R{@}$ ~ 2 ) { if ( i < 0 ) break; sout | i; }
 for ( i; 12.1 ~ $\R{@}$ ~ $\R{@}$ ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 ~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 ~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
 for ( i; 5 @:@ j; -5 -~ $@$ ~ 2 @:@ k; 1.5 ~ $@$ ) { sout | i | j | k; }
 for ( i; 5 @:@ k; 1.5 ~ $@$ @:@ j; -5 -~ $@$ ~ 2 ) { sout | i | j | k; }
+for ( ®i; start ~ comp ~ inc + 1® ) { sout | i; }
+for ( i; 1 ~ ®@® ) { if ( i > 10 ) break; sout | i; }
+for ( i; 10 -~ ®@® ) { if ( i < 0 ) break; sout | i; }
+for ( i; 2 ~ ®@® ~ 2 ) { if ( i > 10 ) break; sout | i; }
+for ( i; 2.1 ~ ®@® ~ ®@® ) { if ( i > 10.5 ) break; sout | i; i += 1.7; }
+for ( i; 10 -~ ®@® ~ 2 ) { if ( i < 0 ) break; sout | i; }
+for ( i; 12.1 ~ ®@® ~ ®@® ) { if ( i < 2.5 ) break; sout | i; i -= 1.7; }
+for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 ~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ) { sout | i | j; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
+for ( i; 5 ®:® j; -5 -~ @ ~ 2 ®:® k; 1.5 ~ @ ) { sout | i | j | k; }
+for ( i; 5 ®:® k; 1.5 ~ @ ®:® j; -5 -~ @ ~ 2 ) { sout | i | j | k; }
 \end{cfa}
+&
 …
 The loop index is polymorphic in the type of the comparison value N (when the start value is implicit) or the start value M.
 \begin{cfa}
 for ( i; @5@ )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
 for ( i; @1.5@~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
+for ( i; ®5® )                                  $\C[2.5in]{// typeof(5) i; 5 is comparison value}$
+for ( i; ®1.5®~5.5~0.5 )                $\C{// typeof(1.5) i; 1.5 is start value}$
 \end{cfa}
 \item
 An empty conditional implies comparison value of ©1© (true).
 \begin{cfa}
 while ( $\R{/*empty*/}$ )               $\C{// while ( true )}$
 for ( $\R{/*empty*/}$ )                 $\C{// for ( ; true; )}$
 do ... while ( $\R{/*empty*/}$ ) $\C{// do ... while ( true )}$
+while ( ®/*empty*/®  )                  $\C{// while ( true )}$
+for ( ®/*empty*/®  )                    $\C{// for ( ; true; )}$
+do ... while ( ®/*empty*/®  )    $\C{// do ... while ( true )}$
 \end{cfa}
 \item
 A comparison N is implicit up-to exclusive range [0,N\R{)}.
 \begin{cfa}
 for ( @5@ )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
+for ( ®5® )                                             $\C{// for ( typeof(5) i; i < 5; i += 1 )}$
 \end{cfa}
 \item
 A comparison ©=© N is implicit up-to inclusive range [0,N\R{]}.
 \begin{cfa}
 for ( @=@5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
+for ( ®=®5 )                                    $\C{// for ( typeof(5) i; i <= 5; i += 1 )}$
 \end{cfa}
 \item
 The up-to range M ©~©\index{~@©~©} N means exclusive range [M,N\R{)}.
 \begin{cfa}
 for ( 1@~@5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
+for ( 1®~®5 )                                   $\C{// for ( typeof(1) i = 1; i < 5; i += 1 )}$
 \end{cfa}
 \item
 The up-to range M ©~=©\index{~=@©~=©} N means inclusive range [M,N\R{]}.
 \begin{cfa}
 for ( 1@~=@5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
+for ( 1®~=®5 )                                  $\C{// for ( typeof(1) i = 1; i <= 5; i += 1 )}$
 \end{cfa}
 \item
 The down-to range M ©-~©\index{-~@©-~©} N means exclusive range [N,M\R{)}.
 \begin{cfa}
 for ( 1@-~@5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
+for ( 1®-~®5 )                                  $\C{// for ( typeof(1) i = 5; i > 0; i -= 1 )}$
 \end{cfa}
 \item
 The down-to range M ©-~=©\index{-~=@©-~=©} N means inclusive range [N,M\R{]}.
 \begin{cfa}
 for ( 1@-~=@5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
+for ( 1®-~=®5 )                                 $\C{// for ( typeof(1) i = 5; i >= 0; i -= 1 )}$
 \end{cfa}
 \item
 ©@© means put nothing in this field.
 \begin{cfa}
 for ( 1~$\R{@}$~2 )                             $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
+for ( 1~®@®~2 )                                 $\C{// for ( typeof(1) i = 1; /*empty*/; i += 2 )}$
 \end{cfa}
 \item
 ©:© means start another index.
 \begin{cfa}
 for ( i; 5 @:@ j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
+for ( i; 5 ®:® j; 2~12~3 )              $\C{// for ( typeof(i) i = 1, j = 2; i < 5 \&\& j < 12; i += 1, j += 3 )}\CRT$
 \end{cfa}
 \end{itemize}
 %\subsection{\texorpdfstring{Labelled \protect\lstinline@continue@ / \protect\lstinline@break@}{Labelled continue / break}}
+%\subsection{\texorpdfstring{Labelled \protect\lstinline{continue} / \protect\lstinline{break}}{Labelled continue / break}}
 \subsection{\texorpdfstring{Labelled \LstKeywordStyle{continue} / \LstKeywordStyle{break} Statement}{Labelled continue / break Statement}}
 …
 \begin{lrbox}{\myboxA}
 \begin{cfa}[tabsize=3]
 @Compound:@ {
         @Try:@ try {
                 @For:@ for ( ... ) {
                         @While:@ while ( ... ) {
                                 @Do:@ do {
                                         @If:@ if ( ... ) {
                                                 @Switch:@ switch ( ... ) {
+®Compound:® {
+        ®Try:® try {
+                ®For:® for ( ... ) {
+                        ®While:® while ( ... ) {
+                                ®Do:® do {
+                                        ®If:® if ( ... ) {
+                                                ®Switch:® switch ( ... ) {
                                                         case 3:
                                                                 @break Compound@;
                                                                 @break Try@;
                                                                 @break For@;      /* or */  @continue For@;
                                                                 @break While@;  /* or */  @continue While@;
                                                                 @break Do@;      /* or */  @continue Do@;
                                                                 @break If@;
                                                                 @break Switch@;
+                                                                ®break Compound®;
+                                                                ®break Try®;
+                                                                ®break For®;      /* or */  ®continue For®;
+                                                                ®break While®;  /* or */  ®continue While®;
+                                                                ®break Do®;      /* or */  ®continue Do®;
+                                                                ®break If®;
+                                                                ®break Switch®;
                                                         } // switch
                                                 } else {
                                                         ... @break If@; ...     // terminate if
+                                                        ... ®break If®; ...     // terminate if
                                                 } // if
                                 } while ( ... ); // do
                         } // while
                 } // for
         } @finally@ { // always executed
+        } ®finally® { // always executed
         } // try
 } // compound
 …
+{
                 @ForC:@ for ( ... ) {
                         @WhileC:@ while ( ... ) {
                                 @DoC:@ do {
+                ®ForC:® for ( ... ) {
+                        ®WhileC:® while ( ... ) {
+                                ®DoC:® do {
                                         if ( ... ) {
                                                 switch ( ... ) {
                                                         case 3:
                                                                 @goto Compound@;
                                                                 @goto Try@;
                                                                 @goto ForB@;      /* or */  @goto ForC@;
                                                                 @goto WhileB@;  /* or */  @goto WhileC@;
                                                                 @goto DoB@;      /* or */  @goto DoC@;
                                                                 @goto If@;
                                                                 @goto Switch@;
                                                         } @Switch:@ ;
+                                                                ®goto Compound®;
+                                                                ®goto Try®;
+                                                                ®goto ForB®;      /* or */  ®goto ForC®;
+                                                                ®goto WhileB®;  /* or */  ®goto WhileC®;
+                                                                ®goto DoB®;      /* or */  ®goto DoC®;
+                                                                ®goto If®;
+                                                                ®goto Switch®;
+                                                        } ®Switch:® ;
                                                 } else {
                                                         ... @goto If@; ...      // terminate if
                                                 } @If:@;
                                 } while ( ... ); @DoB:@ ;
                         } @WhileB:@ ;
                 } @ForB:@ ;
 } @Compound:@ ;
+                                                        ... ®goto If®; ...      // terminate if
+                                                } ®If:®;
+                                } while ( ... ); ®DoB:® ;
+                        } ®WhileB:® ;
+                } ®ForB:® ;
+} ®Compound:® ;
 \end{cfa}
 \end{lrbox}
 …
 %\subsection{\texorpdfstring{\protect\lstinline@with@ Statement}{with Statement}}
+%\subsection{\texorpdfstring{\protect\lstinline{with} Statement}{with Statement}}
 \subsection{\texorpdfstring{\LstKeywordStyle{with} Statement}{with Statement}}
 \label{s:WithStatement}
 …
 \begin{cfa}
 Person p
 @p.@name; @p.@address; @p.@sex; $\C{// access containing fields}$
+®p.®name; ®p.®address; ®p.®sex; $\C{// access containing fields}$
 \end{cfa}
 which extends to multiple levels of qualification for nested aggregates and multiple aggregates.
 \begin{cfa}
 struct Ticket { ... } t;
 @p.name@.first; @p.address@.street;             $\C{// access nested fields}$
 @t.@departure; @t.@cost;                                $\C{// access multiple aggregate}$
+®p.name®.first; ®p.address®.street;             $\C{// access nested fields}$
+®t.®departure; ®t.®cost;                                $\C{// access multiple aggregate}$
 \end{cfa}
 Repeated aggregate qualification is tedious and makes code difficult to read.
 …
 \begin{C++}
 struct S {
         char @c@;   int @i@;   double @d@;
+        char ®c®;   int ®i®;   double ®d®;
         void f( /* S * this */ ) {                              $\C{// implicit ``this'' parameter}$
                 @c@;   @i@;   @d@;                                      $\C{// this->c; this->i; this->d;}$
+                ®c®;   ®i®;   ®d®;                                      $\C{// this->c; this->i; this->d;}$
+        }
+}
 …
 \begin{cfa}
 struct T {
         char @m@;   int @i@;   double @n@;              $\C{// derived class variables}$
+        char ®m®;   int ®i®;   double ®n®;              $\C{// derived class variables}$
 };
 struct S : public T {
         char @c@;   int @i@;   double @d@;              $\C{// class variables}$
         void g( double @d@, T & t ) {
                 d;   @t@.m;   @t@.i;   @t@.n;           $\C{// function parameter}$
                 c;   i;   @this->@d;   @S::@d;          $\C{// class S variables}$
                 m;   @T::@i;   n;                                       $\C{// class T variables}$
+        char ®c®;   int ®i®;   double ®d®;              $\C{// class variables}$
+        void g( double ®d®, T & t ) {
+                d;   ®t®.m;   ®t®.i;   ®t®.n;           $\C{// function parameter}$
+                c;   i;   ®this->®d;   ®S::®d;          $\C{// class S variables}$
+                m;   ®T::®i;   n;                                       $\C{// class T variables}$
+        }
 };
 …
 Hence, the qualified fields become variables with the side-effect that it is simpler to write, easier to read, and optimize field references in a block.
 \begin{cfa}
 void f( S & this ) @with ( this )@ {            $\C{// with statement}$
         @c@;   @i@;   @d@;                                              $\C{// this.c, this.i, this.d}$
+void f( S & this ) ®with ( this )® {            $\C{// with statement}$
+        ®c®;   ®i®;   ®d®;                                              $\C{// this.c, this.i, this.d}$
+}
 \end{cfa}
 with the generality of opening multiple aggregate-parameters:
 \begin{cfa}
 void g( S & s, T & t ) @with ( s, t )@ {        $\C{// multiple aggregate parameters}$
         c;   @s.@i;   d;                                                $\C{// s.c, s.i, s.d}$
         m;   @t.@i;   n;                                                $\C{// t.m, t.i, t.n}$
+void g( S & s, T & t ) ®with ( s, t )® {        $\C{// multiple aggregate parameters}$
+        c;   ®s.®i;   d;                                                $\C{// s.c, s.i, s.d}$
+        m;   ®t.®i;   n;                                                $\C{// t.m, t.i, t.n}$
+}
 \end{cfa}
 …
 The difference between parallel and nesting occurs for fields with the same name and type:
 \begin{cfa}
 struct Q { int @i@; int k; int @m@; } q, w;
 struct R { int @i@; int j; double @m@; } r, w;
+struct Q { int ®i®; int k; int ®m®; } q, w;
+struct R { int ®i®; int j; double ®m®; } r, w;
 with ( r, q ) {
         j + k;                                                                  $\C{// unambiguous, r.j + q.k}$
 …
 \begin{cfa}
 void ?{}( S & s, int i ) with ( s ) { $\C{// constructor}$
         @s.i = i;@  j = 3;  m = 5.5; $\C{// initialize fields}$
+        ®s.i = i;®  j = 3;  m = 5.5; $\C{// initialize fields}$
+}
 \end{cfa}
 …
 and implicitly opened \emph{after} a function-body open, to give them higher priority:
 \begin{cfa}
 void ?{}( S & s, int @i@ ) with ( s ) @with( $\emph{\R{params}}$ )@ { // syntax not allowed, illustration only
         s.i = @i@; j = 3; m = 5.5;
+void ?{}( S & s, int ®i® ) with ( s ) ®with( $\emph{\R{params}}$ )® { // syntax not allowed, illustration only
+        s.i = ®i®; j = 3; m = 5.5;
+}
 \end{cfa}
 …
 For example, a routine returning a \Index{pointer} to an array of integers is defined and used in the following way:
 \begin{cfa}
 int @(*@f@())[@5@]@ {...}; $\C{// definition}$
  ... @(*@f@())[@3@]@ += 1; $\C{// usage}$
+int ®(*®f®())[®5®]® {...}; $\C{// definition}$
+ ... ®(*®f®())[®3®]® += 1; $\C{// usage}$
 \end{cfa}
 Essentially, the return type is wrapped around the routine name in successive layers (like an \Index{onion}).
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
 #[5] *# @int@ x1;
 #* [5]# @int@ x2;
 #[* [5] int]# f@( int p )@;
+#[5] *# ®int® x1;
+#* [5]# ®int® x2;
+#[* [5] int]# f®( int p )®;
 \end{cfa}
+&
 \begin{cfa}[moredelim={**[is][\color{blue}]{\#}{\#}}]
 @int@ #*# x1 #[5]#;
 @int@ #(*#x2#)[5]#;
 #int (*#f@( int p )@#)[5]#;
+®int® #*# x1 #[5]#;
+®int® #(*#x2#)[5]#;
+#int (*#f®( int p )®#)[5]#;
 \end{cfa}
 \end{tabular}
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 @*@ int x, y;
+®*® int x, y;
 \end{cfa}
+&
 \begin{cfa}
 int @*@x, @*@y;
+int ®*®x, ®*®y;
 \end{cfa}
 \end{tabular}
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 @*@ int x;
+®*® int x;
 int y;
 \end{cfa}
+&
 \begin{cfa}
 int @*@x, y;
+int ®*®x, y;
 \end{cfa}
 …
+&
 \begin{cfa}
 int * @const@ x = (int *)100
+int * ®const® x = (int *)100
 *x = 3;                 // implicit dereference
 int * @const@ y = (int *)104;
+int * ®const® y = (int *)104;
 *y = *x;                        // implicit dereference
 \end{cfa}
 …
 \begin{tabular}{@{}l@{\hspace{2em}}l@{}}
 \begin{cfa}
 int x, y, @*@ p1, @*@ p2, @**@ p3;
 p1 = @&@x;     // p1 points to x
+int x, y, ®*® p1, ®*® p2, ®**® p3;
+p1 = ®&®x;     // p1 points to x
 p2 = p1;     // p2 points to x
 p1 = @&@y;     // p1 points to y
+p1 = ®&®y;     // p1 points to y
 p3 = &p2;  // p3 points to p2
 \end{cfa}
 …
 \begin{cfa}
 p1 = p2; $\C{// pointer address assignment}$
 @*@p2 = @*@p1 + x; $\C{// pointed-to value assignment / operation}$
+®*®p2 = ®*®p1 + x; $\C{// pointed-to value assignment / operation}$
 \end{cfa}
 The C semantics work well for situations where manipulation of addresses is the primary meaning and data is rarely accessed, such as storage management (©malloc©/©free©).
 …
 To support this common case, a reference type is introduced in \CFA, denoted by ©&©, which is the opposite dereference semantics to a pointer type, making the value at the pointed-to location the implicit semantics for dereferencing (similar but not the same as \CC \Index{reference type}s).
 \begin{cfa}
 int x, y, @&@ r1, @&@ r2, @&&@ r3;
 @&@r1 = &x; $\C{// r1 points to x}$
 @&@r2 = &r1; $\C{// r2 points to x}$
 @&@r1 = &y; $\C{// r1 points to y}$
 @&&@r3 = @&@&r2; $\C{// r3 points to r2}$
+int x, y, ®&® r1, ®&® r2, ®&&® r3;
+®&®r1 = &x; $\C{// r1 points to x}$
+®&®r2 = &r1; $\C{// r2 points to x}$
+®&®r1 = &y; $\C{// r1 points to y}$
+®&&®r3 = ®&®&r2; $\C{// r3 points to r2}$
 r2 = ((r1 + r2) * (r3 - r1)) / (r3 - 15); $\C{// implicit dereferencing}$
 \end{cfa}
 …
 One way to conceptualize a reference is via a rewrite rule, where the compiler inserts a dereference operator before the reference variable for each reference qualifier in a declaration, so the previous example becomes:
 \begin{cfa}
 @*@r2 = ((@*@r1 + @*@r2) @*@ (@**@r3 - @*@r1)) / (@**@r3 - 15);
+®*®r2 = ((®*®r1 + ®*®r2) ®*® (®**®r3 - ®*®r1)) / (®**®r3 - 15);
 \end{cfa}
 When a reference operation appears beside a dereference operation, \eg ©&*©, they cancel out.
 …
 For a \CFA reference type, the cancellation on the left-hand side of assignment leaves the reference as an address (\Index{lvalue}):
 \begin{cfa}
 (&@*@)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
+(&®*®)r1 = &x; $\C{// (\&*) cancel giving address in r1 not variable pointed-to by r1}$
 \end{cfa}
 Similarly, the address of a reference can be obtained for assignment or computation (\Index{rvalue}):
 \begin{cfa}
 (&(&@*@)@*@)r3 = &(&@*@)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
+(&(&®*®)®*®)r3 = &(&®*®)r2; $\C{// (\&*) cancel giving address in r2, (\&(\&*)*) cancel giving address in r3}$
 \end{cfa}
 Cancellation\index{cancellation!pointer/reference}\index{pointer!cancellation} works to arbitrary depth.
 …
 const int cx = 5; $\C{// cannot change cx;}$
 const int & cr = cx; $\C{// cannot change what cr points to}$
 @&@cr = &cx; $\C{// can change cr}$
+®&®cr = &cx; $\C{// can change cr}$
 cr = 7; $\C{// error, cannot change cx}$
 int & const rc = x; $\C{// must be initialized}$
 @&@rc = &x; $\C{// error, cannot change rc}$
+®&®rc = &x; $\C{// error, cannot change rc}$
 const int & const crc = cx; $\C{// must be initialized}$
 crc = 7; $\C{// error, cannot change cx}$
 @&@crc = &cx; $\C{// error, cannot change crc}$
+®&®crc = &cx; $\C{// error, cannot change crc}$
 \end{cfa}
 Hence, for type ©& const©, there is no pointer assignment, so ©&rc = &x© is disallowed, and \emph{the address value cannot be the null pointer unless an arbitrary pointer is coerced\index{coercion} into the reference}:
 …
 \multicolumn{1}{c@{\hspace{3em}}}{\textbf{\CFA}}        & \multicolumn{1}{c}{\textbf{C}}        \\
 \begin{cfa}
 @const@ * @const@ * const int ccp;
 @const@ & @const@ & const int ccr;
+®const® * ®const® * const int ccp;
+®const® & ®const® & const int ccr;
 \end{cfa}
+&
 \begin{cfa}
 const int * @const@ * @const@ ccp;
+const int * ®const® * ®const® ccp;
 \end{cfa}
 …
 \begin{cfa}
 int * p = &x; $\C{// assign address of x}$
 @int * p = x;@ $\C{// assign value of x}$
+®int * p = x;® $\C{// assign value of x}$
 int & r = x; $\C{// must have address of x}$
 \end{cfa}
 …
 When a pointer/reference parameter has a ©const© value (immutable), it is possible to pass literals and expressions.
 \begin{cfa}
 void f( @const@ int & cr );
 void g( @const@ int * cp );
 f( 3 );                   g( @&@3 );
 f( x + y );             g( @&@(x + y) );
+void f( ®const® int & cr );
+void g( ®const® int * cp );
+f( 3 );                   g( ®&®3 );
+f( x + y );             g( ®&®(x + y) );
 \end{cfa}
 Here, the compiler passes the address to the literal 3 or the temporary for the expression ©x + y©, knowing the argument cannot be changed through the parameter.
 …
 void f( int & r );
 void g( int * p );
 f( 3 );                   g( @&@3 ); $\C{// compiler implicit generates temporaries}$
 f( x + y );             g( @&@(x + y) ); $\C{// compiler implicit generates temporaries}$
+f( 3 );                   g( ®&®3 ); $\C{// compiler implicit generates temporaries}$
+f( x + y );             g( ®&®(x + y) ); $\C{// compiler implicit generates temporaries}$
 \end{cfa}
 Essentially, there is an implicit \Index{rvalue} to \Index{lvalue} conversion in this case.\footnote{
 …
 Instead, a routine object should be referenced by a ©const© reference:
 \begin{cfa}
 @const@ void (@&@ fr)( int ) = f; $\C{// routine reference}$
+®const® void (®&® fr)( int ) = f; $\C{// routine reference}$
 fr = ... $\C{// error, cannot change code}$
 &fr = ...; $\C{// changing routine reference}$
 …
 \begin{cfa}
 int x, &r = x, f( int p );
 x = @r@ + f( @r@ ); $\C{// lvalue reference converts to rvalue}$
+x = ®r® + f( ®r® ); $\C{// lvalue reference converts to rvalue}$
 \end{cfa}
 An rvalue has no type qualifiers (©cv©), so the reference qualifiers are dropped.
 \item
 lvalue to reference conversion: \lstinline[deletekeywords=lvalue]@lvalue-type cv1 T@ converts to ©cv2 T &©, which allows implicitly converting variables to references.
 \begin{cfa}
 int x, &r = @x@, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
 f( @x@ ); $\C{// lvalue variable (int) convert to reference (int \&)}$
+lvalue to reference conversion: \lstinline[deletekeywords=lvalue]{lvalue-type cv1 T} converts to ©cv2 T &©, which allows implicitly converting variables to references.
+\begin{cfa}
+int x, &r = ®x®, f( int & p ); $\C{// lvalue variable (int) convert to reference (int \&)}$
+f( ®x® ); $\C{// lvalue variable (int) convert to reference (int \&)}$
 \end{cfa}
 Conversion can restrict a type, where ©cv1© $\le$ ©cv2©, \eg passing an ©int© to a ©const volatile int &©, which has low cost.
 …
 \begin{cfa}
 int x, & f( int & p );
 f( @x + 3@ );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
 @&f@(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
+f( ®x + 3® );   $\C[1.5in]{// rvalue parameter (int) implicitly converts to lvalue temporary reference (int \&)}$
+®&f®(...) = &x; $\C{// rvalue result (int \&) implicitly converts to lvalue temporary reference (int \&)}\CRT$
 \end{cfa}
 In both case, modifications to the temporary are inaccessible (\Index{warning}).
 …
+\section{Enumeration}
+An \newterm{enumeration} is a compile-time mechanism to alias names to constants, like ©typedef© is a mechanism to alias names to types.
+Its purpose is to define a restricted-value type providing code-readability and maintenance -- changing an enum's value automatically updates all name usages during compilation.
+An enumeration type is a set of names, each called an \newterm{enumeration constant} (shortened to \newterm{enum}) aliased to a fixed value (constant).
+\begin{cfa}
+enum Days { Mon, Tue, Wed, Thu, Fri, Sat, Sun }; // enumeration type definition, set of 7 names & values
+Days days = Mon; // enumeration type declaration and initialization
+\end{cfa}
+The set of enums are injected into the variable namespace at the definition scope.
+Hence, enums may be overloaded with enum/variable/function names.
+\begin{cfa}
+enum Foo { Bar };
+enum Goo { Bar };       $\C[1.75in]{// overload Foo.Bar}$
+int Foo;                        $\C{// type/variable separate namespace}$
+double Bar;                     $\C{// overload Foo.Bar, Goo.Bar}\CRT$
+\end{cfa}
+An anonymous enumeration injects enums with specific values into a scope.
+\begin{cfa}
+enum { Prime = 103, BufferSize = 1024 };
+\end{cfa}
+An enumeration is better than using C \Index{preprocessor} or constant declarations.
+\begin{cquote}
+\begin{tabular}{@{}l@{\hspace{4em}}l@{}}
+\begin{cfa}
+#define Mon 0
+...
+#define Sun 6
+\end{cfa}
+&
+\begin{cfa}
+const int Mon = 0,
+                         ...,
+                         Sun = 6;
+\end{cfa}
+\end{tabular}
+\end{cquote}
+because the enumeration is succinct, has automatic numbering, can appear in ©case© labels, does not use storage, and is part of the language type-system.
+Finally, the type of an enum is implicitly or explicitly specified and the constant value can be implicitly or explicitly specified.
+Note, enum values may be repeated in an enumeration.
+\subsection{Enum type}
+The type of enums can be any type, and an enum's value comes from this type.
+Because an enum is a constant, it cannot appear in a mutable context, \eg ©Mon = Sun© is disallowed, and has no address (it is an rvalue).
+Therefore, an enum is automatically converted to its constant's base-type, \eg comparing/printing an enum compares/prints its value rather than the enum name;
+there is no mechanism to print the enum name.
+The default enum type is ©int©.
+Hence, ©Days© is the set type ©Mon©, ©Tue©, ...\,, ©Sun©, while the type of each enum is ©int© and each enum represents a fixed integral value.
+If no values are specified for an integral enum type, the enums are automatically numbered by one from left to right starting at zero.
+Hence, the value of enum ©Mon© is 0, ©Tue© is 1, ...\,, ©Sun© is 6.
+If an enum value is specified, numbering continues by one from that value for subsequent unnumbered enums.
+If an enum value is an expression, the compiler performs constant-folding to obtain a constant value.
+\CFA allows other integral types with associated values.
+\begin{cfa}
+enum( ®char® ) Letter { A ®= 'A'®,  B,  C,  I ®= 'I'®,  J,  K };
+enum( ®long long int® ) BigNum { X = 123_456_789_012_345,  Y = 345_012_789_456_123 };
+\end{cfa}
+For enumeration ©Letter©, enum ©A©'s value is explicitly set to ©'A'©, with ©B© and ©C© implicitly numbered with increasing values from ©'A'©, and similarly for enums ©I©, ©J©, and ©K©.
+Non-integral enum types must be explicitly initialized, \eg ©double© is not automatically numbered by one.
+\begin{cfa}
+// non-integral numeric
+enum( ®double® ) Math { PI_2 = 1.570796, PI = 3.141597,  E = 2.718282 }
+// pointer
+enum( ®char *® ) Name { Fred = "Fred",  Mary = "Mary",  Jane = "Jane" };
+int i, j, k;
+enum( ®int *® ) ptr { I = &i,  J = &j,  K = &k };
+enum( ®int &® ) ref { I = i,  J = j,  K = k };
+// tuple
+enum( ®[int, int]® ) { T = [ 1, 2 ] };
+// function
+void f() {...}   void g() {...}
+enum( ®void (*)()® ) funs { F = f,  F = g };
+// aggregate
+struct S { int i, j; };
+enum( ®S® ) s { A = { 3,  4 }, B = { 7,  8 } };
+// enumeration
+enum( ®Letter® ) Greek { Alph = A, Beta = B, /* more enums */  }; // alphabet intersection
+\end{cfa}
+Enumeration ©Greek© may have more or less enums than ©Letter©, but the enum values \emph{must} be from ©Letter©.
+Therefore, ©Greek© enums are a subset of type ©Letter© and are type compatible with enumeration ©Letter©, but ©Letter© enums are not type compatible with enumeration ©Greek©.
+The following examples illustrate the difference between the enumeration type and the type of its enums.
+\begin{cfa}
+Math m = PI;    $\C[1.5in]{// allowed}$
+double d = PI;  $\C{// allowed, conversion to base type}$
+m = E;                  $\C{// allowed}$
+m = Alph;               $\C{// {\color{red}disallowed}}$
+m = 3.141597;   $\C{// {\color{red}disallowed}}$
+d = m;                  $\C{// allowed}$
+d = Alph;               $\C{// {\color{red}disallowed}}$
+Letter l = A;   $\C{// allowed}$
+Greek g = Alph; $\C{// allowed}$
+l = Alph;               $\C{// allowed, conversion to base type}$
+g = A;                  $\C{// {\color{red}disallowed}}\CRT$
+\end{cfa}
+A constructor \emph{cannot} be used to initialize enums because a constructor executes at runtime.
+A fallback is explicit C-style initialization using ©@=©.
+\begin{cfa}
+enum( struct vec3 ) Axis { Up @= { 1, 0, 0 }, Left @= { 0, 1, 0 }, Front @= { 0, 0, 1 } }
+\end{cfa}
+Finally, enumeration variables are assignable and comparable only if the appropriate operators are defined for its enum type.
+\subsection{Inheritance}
+\Index{Plan-9}\index{inheritance!enumeration} inheritance may be used with enumerations.
+\begin{cfa}
+enum( char * ) Name2 { ®inline Name®, Jack = "Jack", Jill = "Jill" };
+enum ®/* inferred */®  Name3 { ®inline Name2®, Sue = "Sue", Tom = "Tom" };
+\end{cfa}
+Enumeration ©Name2© inherits all the enums and their values from enumeration ©Name© by containment, and a ©Name© enumeration is a subtype of enumeration ©Name2©.
+Note, enums must be unique in inheritance but enum values may be repeated.
+The enum type for the inheriting type must be the same as the inherited type;
+hence the enum type may be omitted for the inheriting enumeration and it is inferred from the inherited enumeration, as for ©Name3©.
+When inheriting from integral types, automatic numbering may be used, so the inheritance placement left to right is important, \eg the placement of ©Sue© and ©Tom© before or after ©inline Name2©.
+Specifically, the inheritance relationship for ©Name©s is:
+\begin{cfa}
+Name $\(\subseteq\)$ Name2 $\(\subseteq\)$ Name3 $\(\subseteq\)$ const char * // enum type of Name
+\end{cfa}
+Hence, given
+\begin{cfa}
+void f( Name );
+void g( Name2 );
+void h( Name3 );
+void j( const char * );
+\end{cfa}
+the following calls are valid
+\begin{cfa}
+f( Fred );
+g( Fred );   g( Jill );
+h( Fred );   h( Jill );   h( Sue );
+j( Fred );    j( Jill );    j( Sue );    j( 'W' );
+\end{cfa}
+Note, the validity of calls is the same for call-by-reference as for call-by-value, and ©const© restrictions are the same as for other types.
+Enums cannot be created at runtime, so inheritence problems, such as contra-variance do not apply.
+Only instances of the enum base-type may be created at runtime.
+\begin{comment}
+The invariance of references, as I show at the bottom, is easy to overlook.  Not shown, but on the same topic, is that returns work in the opposite direction as parameters.  Hopefully our existing type rules already know both those facts, so that we'd only have to provide the rules that I suggest using the by-value parameters.
+The Fred, Jack, and Mary declarations are picked verbatim from our earlier whiteboard, just repeated here for reference.
+\begin{cfa}
+// Fred is a subset of char *
+enum( char *) Fred { A = "A", B = "B", C = "C" };
+// Jack is a subset of Fred
+enum( enum Fred ) Jack { W = A, Y = C};
+// Mary is a superset of Fred
+enum Mary { inline Fred, D = "hello" };
+// Demonstrating invariance of references
+[void] frcs( & * char x ) { char * x0 = x; x = "bye"; }
+[void] frf ( & Fred   x ) { Fred   x0 = x; x = B;     }
+[void] frj ( & Jack   x ) { Jack   x0 = x; x = W;     }
+[void] frm ( & Mary   x ) { Mary   x0 = x; x = D;     }
+char * vcs;
+Fred   vf;
+Jack   vj;
+Mary   vm;
+// all variant calls: bad  (here are noteworthy examples)
+             frcs( vf  );  // can't assign "bye" to vf
+             frm ( vf  );  // can't assign D     to vf
+             frf ( vj  );  // can't assign B     to vj
+vf  = B    ; frj ( vf  );  // can't assign B     to frj.x0
+vcs = "bye"; frf ( vcs );  // can't assign "bye" to frf.x0
+\end{cfa}
+This example is really great. However, I think it's work explicitly doing one with ©const &©.
+\end{comment}
 \section{Routine Definition}
 \CFA also supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
+\CFA supports a new syntax for routine definition, as well as \Celeven and K\&R routine syntax.
 The point of the new syntax is to allow returning multiple values from a routine~\cite{Galletly96,CLU}, \eg:
 \begin{cfa}
 @[ int o1, int o2, char o3 ]@ f( int i1, char i2, char i3 ) {
+®[ int o1, int o2, char o3 ]® f( int i1, char i2, char i3 ) {
         $\emph{routine body}$
+}
 \end{cfa}
 where routine ©f© has three output (return values) and three input parameters.
 Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type specifications.
+Existing C syntax cannot be extended with multiple return types because it is impossible to embed a single routine name within multiple return type-specifications.
 In detail, the brackets, ©[]©, enclose the result type, where each return value is named and that name is a local variable of the particular return type.\footnote{
 …
 Declaration qualifiers can only appear at the start of a routine definition, \eg:
 \begin{cfa}
 @extern@ [ int x ] g( int y ) {$\,$}
+®extern® [ int x ] g( int y ) {$\,$}
 \end{cfa}
 Lastly, if there are no output parameters or input parameters, the brackets and/or parentheses must still be specified;
 …
 int (*f(x))[ 5 ] int x; {}
 \end{cfa}
 The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter x of type array of 5 integers.
+The string ``©int (*f(x))[ 5 ]©'' declares a K\&R style routine of type returning a pointer to an array of 5 integers, while the string ``©[ 5 ] int x©'' declares a \CFA style parameter ©x© of type array of 5 integers.
 Since the strings overlap starting with the open bracket, ©[©, there is an ambiguous interpretation for the string.
 As well, \CFA-style declarations cannot be used to declare parameters for C-style routine-definitions because of the following ambiguity:
 …
 \begin{minipage}{\linewidth}
 \begin{cfa}
 @[ int x, int y ]@ f() {
+®[ int x, int y ]® f() {
         int z;
         ... x = 0; ... y = z; ...
         @return;@ $\C{// implicitly return x, y}$
+        ®return;® $\C{// implicitly return x, y}$
+}
 \end{cfa}
 …
 int fred() {
         s.t.c = @S.@R;  // type qualification
         struct @S.@T t = { @S.@R, 1, 2 };
         enum @S.@C c;
         union @S.T.@U u;
+        s.t.c = ®S.®R;  // type qualification
+        struct ®S.®T t = { ®S.®R, 1, 2 };
+        enum ®S.®C c;
+        union ®S.T.®U u;
+}
 \end{cfa}
 …
 qsort( ia, size ); $\C{// sort ascending order using builtin ?<?}$
+{
         @int ?<?( int x, int y ) { return x > y; }@ $\C{// nested routine}$
+        ®int ?<?( int x, int y ) { return x > y; }® $\C{// nested routine}$
         qsort( ia, size ); $\C{// sort descending order by local redefinition}$
+}
 …
 \begin{cfa}
 [* [int]( int )] foo() { $\C{// int (* foo())( int )}$
         int @i@ = 7;
+        int ®i® = 7;
         int bar( int p ) {
                 @i@ += 1; $\C{// dependent on local variable}$
                 sout | @i@;
+                ®i® += 1; $\C{// dependent on local variable}$
+                sout | ®i®;
+        }
         return bar; $\C{// undefined because of local dependence}$
 …
 In C and \CFA, lists of elements appear in several contexts, such as the parameter list of a routine call.
 \begin{cfa}
 f( @2, x, 3 + i@ ); $\C{// element list}$
+f( ®2, x, 3 + i® ); $\C{// element list}$
 \end{cfa}
 A list of elements is called a \newterm{tuple}, and is different from a \Index{comma expression}.
 …
 In \CFA, it is possible to overcome this restriction by declaring a \newterm{tuple variable}.
 \begin{cfa}
 [int, int] @qr@ = div( 13, 5 ); $\C{// initialize tuple variable}$
 printf( "%d %d\n", @qr@ ); $\C{// print quotient/remainder}$
+[int, int] ®qr® = div( 13, 5 ); $\C{// initialize tuple variable}$
+printf( "%d %d\n", ®qr® ); $\C{// print quotient/remainder}$
 \end{cfa}
 It is now possible to match the multiple return-values to a single variable, in much the same way as \Index{aggregation}.
 …
 \begin{cfa}
 int x = 1, y = 2, z = 3;
 sout | x @|@ y @|@ z;
+sout | x ®|® y ®|® z;
 \end{cfa}
+&
 \begin{cfa}
 cout << x @<< " "@ << y @<< " "@ << z << endl;
+cout << x ®<< " "® << y ®<< " "® << z << endl;
 \end{cfa}
+&
 …
 \\
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
 \end{tabular}
 \end{cquote}
 The \CFA form has half the characters of the \CC form, and is similar to \Index*{Python} I/O with respect to implicit separators and newline.
 Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]@, @''.
+Similar simplification occurs for \Index{tuple} I/O, which flattens the tuple and prints each value separated by ``\lstinline[showspaces=true]{, }''.
 \begin{cfa}
 [int, [ int, int ] ] t1 = [ 1, [ 2, 3 ] ], t2 = [ 4, [ 5, 6 ] ];
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 @, @2@, @3 4@, @5@, @6
+®, ®2®, ®3 4®, ®5®, ®6
 \end{cfa}
 Finally, \CFA uses the logical-or operator for I/O as it is the lowest-priority \emph{overloadable} operator, other than assignment.
 …
+&
 \begin{cfa}
 sout | x * 3 | y + 1 | z << 2 | x == y | @(@x | y@)@ | @(@x || y@)@ | @(@x > z ? 1 : 2@)@;
+sout | x * 3 | y + 1 | z << 2 | x == y | ®(®x | y®)® | ®(®x || y®)® | ®(®x > z ? 1 : 2®)®;
 \end{cfa}
 \\
 …
+&
 \begin{cfa}
 cout << x * 3 << y + 1 << @(@z << 2@)@ << @(@x == y@)@ << @(@x | y@)@ << @(@x || y@)@ << @(@x > z ? 1 : 2@)@ << endl;
+cout << x * 3 << y + 1 << ®(®z << 2®)® << ®(®x == y®)® << ®(®x | y®)® << ®(®x || y®)® << ®(®x > z ? 1 : 2®)® << endl;
 \end{cfa}
 \\
 …
 \\
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@1@ @2.5@ @A@
+®1® ®2.5® ®A®
 …
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@1@ @2.5@ @A@
+®1® ®2.5® ®A®
 …
+&
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@1@
+@2.5@
+@A@
+®1®
+®2.5®
+®A®
 \end{cfa}
 \end{tabular}
 …
 \item
 A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} a closing citation mark.
+A separator does not appear before a C string starting with the (extended) \Index*{ASCII}\index{ASCII!extended} characters: \LstStringStyle{,.;!?)]\}\%\textcent\guillemotright}, where \LstStringStyle{\guillemotright} is a closing citation mark.
 \begin{cfa}
 sout | 1 | ", x" | 2 | ". x" | 3 | "; x" | 4 | "! x" | 5 | "? x" | 6 | "% x"
 …
 \end{cfa}
 \begin{cfa}[showspaces=true]
 @,@ x 2@.@ x 3@;@ x 4@!@ x 5@?@ x 6@%@ x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9@)@ x 10@]@ x 11@}@ x
+®,® x 2®.® x 3®;® x 4®!® x 5®?® x 6®%® x 7$\R{\LstStringStyle{\textcent}}$ x 8$\R{\LstStringStyle{\guillemotright}}$ x 9®)® x 10®]® x 11®}® x
 \end{cfa}
 …
 %$
 \begin{cfa}
 sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
+sout | "x (" | 1 | "x [" | 2 | "x {" | 3 | "x =" | 4 | "x $\LstStringStyle{\textdollar}$" | 5 | "x $\LstStringStyle{\textsterling}$" | 6 | "x $\LstStringStyle{\textyen}$"
            | 7 | "x $\LstStringStyle{\textexclamdown}$" | 8 | "x $\LstStringStyle{\textquestiondown}$" | 9 | "x $\LstStringStyle{\guillemotleft}$" | 10;
 \end{cfa}
 %$
 \begin{cfa}[showspaces=true]
 x @(@1 x @[@2 x @{@3 x @=@4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
+x ®(®1 x ®[®2 x ®{®3 x ®=®4 x $\LstStringStyle{\textdollar}$5 x $\R{\LstStringStyle{\textsterling}}$6 x $\R{\LstStringStyle{\textyen}}$7 x $\R{\LstStringStyle{\textexclamdown}}$8 x $\R{\LstStringStyle{\textquestiondown}}$9 x $\R{\LstStringStyle{\guillemotleft}}$10
 \end{cfa}
 %$
 \item
 A seperator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n}
+A separator does not appear before/after a C string starting/ending with the \Index*{ASCII} quote or whitespace characters: \lstinline[basicstyle=\tt,showspaces=true]{`'": \t\v\f\r\n}
 \begin{cfa}
 sout | "x`" | 1 | "`x'" | 2 | "'x\"" | 3 | "\"x:" | 4 | ":x " | 5 | " x\t" | 6 | "\tx";
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
 x@`@1@`@x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x@:@4@:@x@ @5@ @x@  @6@     @x
+x®`®1®`®x$\R{\texttt{'}}$2$\R{\texttt{'}}$x$\R{\texttt{"}}$3$\R{\texttt{"}}$x®:®4®:®x® ®5® ®x®  ®6®     ®x
 \end{cfa}
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,showtabs=true]
 x (@ @1@ @) x 2@ @, x 3@ @:x:@ @4
+x (® ®1® ®) x 2® ®, x 3® ®:x:® ®4
 \end{cfa}
 \end{enumerate}
 …
 \Indexc{sepSet}\index{manipulator!sepSet@©sepSet©} and \Indexc{sep}\index{manipulator!sep@©sep©}/\Indexc{sepGet}\index{manipulator!sepGet@©sepGet©} set and get the separator string.
 The separator string can be at most 16 characters including the ©'\0'© string terminator (15 printable characters).
+\begin{cfa}[escapechar=off,belowskip=0pt]
+sepSet( sout, ", $" ); $\C{// set separator from " " to ", \$"}$
+sout | 1 | 2 | 3 | " \"" | @sep@ | "\"";
+\end{cfa}
+%$
+\begin{cfa}[mathescape=off,showspaces=true,aboveskip=0pt]
+@, $@2@, $@3 @", $"@
+\end{cfa}
+%$
+\begin{cfa}[belowskip=0pt]
+sepSet( sout, ", $\LstStringStyle{\textdollar}$" ); $\C{// set separator from " " to ", \$"}$
+sout | 1 | 2 | 3 | " \"" | ®sep® | "\"";
+\end{cfa}
+\begin{cfa}[showspaces=true,aboveskip=0pt]
+®, $\LstStringStyle{\textdollar}$®2®, $\LstStringStyle{\textdollar}$®3 ®", $\LstStringStyle{\textdollar}$"®
+\end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSet( sout, " " ); $\C{// reset separator to " "}$
 sout | 1 | 2 | 3 | " \"" | @sepGet( sout )@ | "\"";
+sout | 1 | 2 | 3 | " \"" | ®sepGet( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 @ @2@ @3 @" "@
+® ®2® ®3 ®" "®
 \end{cfa}
 ©sepGet© can be used to store a separator and then restore it:
 \begin{cfa}[belowskip=0pt]
 char store[@sepSize@]; $\C{// sepSize is the maximum separator size}$
+char store[®sepSize®]; $\C{// sepSize is the maximum separator size}$
 strcpy( store, sepGet( sout ) ); $\C{// copy current separator}$
 sepSet( sout, "_" ); $\C{// change separator to underscore}$
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @_@2@_@3
+®_®2®_®3
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 @ @2@ @3
+® ®2® ®3
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, " " ); $\C{// set tuple separator from ", " to " "}$
 sout | t1 | t2 | " \"" | @sepTuple@ | "\"";
+sout | t1 | t2 | " \"" | ®sepTuple® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 2 3 4 5 6 @" "@
+2 3 4 5 6 ®" "®
 \end{cfa}
 \begin{cfa}[belowskip=0pt]
 sepSetTuple( sout, ", " ); $\C{// reset tuple separator to ", "}$
 sout | t1 | t2 | " \"" | @sepGetTuple( sout )@ | "\"";
+sout | t1 | t2 | " \"" | ®sepGetTuple( sout )® | "\"";
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt]
 , 2, 3 4, 5, 6 @", "@
+, 2, 3 4, 5, 6 ®", "®
 \end{cfa}
 As for ©sepGet©, ©sepGetTuple© can be use to store a tuple separator and then restore it.
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@ @1 2 3@ @
+® ®1 2 3® ®
 \end{cfa}
 \end{enumerate}
 …
 For example, in:
 \begin{cfa}
 sin | i | @nl@ | j;
 @2@
+sin | i | ®nl® | j;
+®2®
 \end{cfa}
 …
 b0 0b11011 0b11011 0b11011 0b11011
 sout | bin( -27HH ) | bin( -27H ) | bin( -27 ) | bin( -27L );
 b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b@(58 1s)@100101
+b11100101 0b1111111111100101 0b11111111111111111111111111100101 0b®(58 1s)®100101
 \end{cfa}
 …
 \item
+\Indexc{eng}( floating-point )\index{manipulator!eng@©eng©} print value in engineering notation with exponent, which means the exponent is adjusted to a multiple of 3.
+\begin{cfa}[belowskip=0pt]
+sout | eng( 0.0 ) | eng( 27000.5 ) | eng( -27.5e7 );
+®e0® 27.0005®e3® -275®e6®
+\end{cfa}
+\item
+\Indexc{unit}( engineering-notation )\index{manipulator!unit@©unit©} print engineering exponent as a letter between the range $10^{-24}$ and $10^{24}$:
+©y© $\Rightarrow 10^{-24}$, ©z© $\Rightarrow 10^{-21}$, ©a© $\Rightarrow 10^{-18}$, ©f© $\Rightarrow 10^{-15}$, ©p© $\Rightarrow 10^{-12}$, ©n© $\Rightarrow 10^{-9}$, ©u© $\Rightarrow 10^{-6}$, ©m© $\Rightarrow 10^{-3}$, ©K© $\Rightarrow 10^{3}$, ©M© $\Rightarrow 10^{6}$, ©G© $\Rightarrow 10^{9}$, ©T© $\Rightarrow 10^{12}$, ©P© $\Rightarrow 10^{15}$, ©E© $\Rightarrow 10^{18}$, ©Z© $\Rightarrow 10^{21}$, ©Y© $\Rightarrow 10^{24}$.
+For exponent $10^{0}$, no decimal point or letter is printed.
+\begin{cfa}[belowskip=0pt]
+sout | unit(eng( 0.0 )) | unit(eng( 27000.5 )) | unit(eng( -27.5e7 ));
+27.0005®K® -275®M®
+\end{cfa}
+\item
 \Indexc{upcase}( bin / hex / floating-point )\index{manipulator!upcase@©upcase©} print letters in a value in upper case. Lower case is the default.
 \begin{cfa}[belowskip=0pt]
 sout | upcase( bin( 27 ) ) | upcase( hex( 27 ) ) | upcase( 27.5e-10 ) | upcase( hex( 27.5 ) );
 @B@11011 0@X@1@B@ 2.75@E@-09 0@X@1.@B@8@P@+4
+®B®11011 0®X®1®B® 2.75®E®-09 0®X®1.®B®8®P®+4
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sout | 0. | nodp( 0. ) | 27.0 | nodp( 27.0 ) | nodp( 27.5 );
 .0 @0@ 27.0 @27@ 27.5
+.0 ®0® 27.0 ®27® 27.5
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sout | sign( 27 ) | sign( -27 ) | sign( 27. ) | sign( -27. ) | sign( 27.5 ) | sign( -27.5 );
 @+@27 -27 @+@27.0 -27.0 @+@27.5 -27.5
 \end{cfa}
 \item
 \Indexc{wd}©( unsigned char minimum, T val )©\index{manipulator!wd@©wd©}, ©wd( unsigned char minimum, unsigned char precision, T val )©
 For all types, ©minimum© is the minimum number of printed characters.
+®+®27 -27 ®+®27.0 -27.0 ®+®27.5 -27.5
+\end{cfa}
+\item
+\Indexc{wd}( minimum, value )\index{manipulator!wd@©wd©}, ©wd©( minimum, precision, value )
+For all types, minimum is the number of printed characters.
 If the value is shorter than the minimum, it is padded on the right with spaces.
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @  @34 @ @34 34
 @  @4.000000 @ @4.000000 4.000000
 @  @ab @ @ab ab
 \end{cfa}
 If the value is larger, it is printed without truncation, ignoring the ©minimum©.
+®  ®34 ® ®34 34
+®  ®4.000000 ® ®4.000000 4.000000
+®  ®ab ® ®ab ab
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the minimum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4, 34567 ) | wd( 3, 34567 ) | wd( 2, 34567 );
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @7@ 345@67@ 34@567@
 @.@ 345@6.@ 34@56.@
 abcd@e@ abc@de@ ab@cde@
 \end{cfa}
 For integer types, ©precision© is the minimum number of printed digits.
+®7® 345®67® 34®567®
+®.® 345®6.® 34®56.®
+abcd®e® abc®de® ab®cde®
+\end{cfa}
+For integer types, precision is the minimum number of printed digits.
 If the value is shorter, it is padded on the left with leading zeros.
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
  @0@34     @00@34 @00000000@34
 \end{cfa}
 If the value is larger, it is printed without truncation, ignoring the ©precision©.
+ ®0®34     ®00®34 ®00000000®34
+\end{cfa}
+If the value is larger, it is printed without truncation, ignoring the precision.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4,1, 3456 ) | wd( 8,2, 3456 ) | wd( 10,3, 3456 );
 …
      3456       3456
 \end{cfa}
 If ©precision© is 0, nothing is printed for zero.
 If ©precision© is greater than the minimum, it becomes the minimum.
+If precision is 0, nothing is printed for zero.
+If precision is greater than the minimum, it becomes the minimum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 4,0, 0 ) | wd( 3,10, 34 );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @    @ @00000000@34
 \end{cfa}
 For floating-point types, ©precision© is the minimum number of digits after the decimal point.
+®    ® ®00000000®34
+\end{cfa}
+For floating-point types, precision is the minimum number of digits after the decimal point.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 6,3, 27.5 ) | wd( 8,1, 27.5 ) | wd( 8,0, 27.5 ) | wd( 3,8, 27.5 );
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 .@500@     27.@5@      28. 27.@50000000@
 \end{cfa}
 For the C-string type, ©precision© is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
+.®500®     27.®5®      28. 27.®50000000®
+\end{cfa}
+For the C-string type, precision is the maximum number of printed characters, so the string is truncated if it exceeds the maximum.
 \begin{cfa}[belowskip=0pt]
 sout | wd( 6,8, "abcd" ) | wd( 6,8, "abcdefghijk" ) | wd( 6,3, "abcd" );
 …
 \item
+\Indexc{ws( unsigned char minimum, unsigned char significant, floating-point )}\index{manipulator!ws@©ws©}
+For floating-point type, ©minimum© is the same as for manipulator ©wd©, but ©significant© is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
+If a value's significant digits is greater than ©significant©, the last significant digit is rounded up.
+\begin{sloppypar}
+\Indexc{ws}( minimum, significant, floating-point )\index{manipulator!ws@©ws©}
+For floating-point types, minimum is the same as for manipulator ©wd©, but significant is the maximum number of significant digits to be printed for both the integer and fractions (versus only the fraction for ©wd©).
+If a value's significant digits is greater than significant, the last significant digit is rounded up.
+\end{sloppypar}
 \begin{cfa}[belowskip=0pt]
 sout | ws(6,6, 234.567) | ws(6,5, 234.567) | ws(6,4, 234.567) | ws(6,3, 234.567);
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 .567 234.5@7@  234.@6@    23@5@
 \end{cfa}
 If a value's magnitude is greater than ©significant©, the value is printed in scientific notation with the specified number of significant digits.
+.567 234.5®7®  234.®6®    23®5®
+\end{cfa}
+If a value's magnitude is greater than significant, the value is printed in scientific notation with the specified number of significant digits.
 \begin{cfa}[belowskip=0pt]
 sout | ws(6,6, 234567.) | ws(6,5, 234567.) | ws(6,4, 234567.) | ws(6,3, 234567.);
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 . 2.3457@e+05@ 2.346@e+05@ 2.35@e+05@
 \end{cfa}
 If ©significant© is greater than ©minimum©, it defines the number of printed characters.
+. 2.3457®e+05® 2.346®e+05® 2.35®e+05®
+\end{cfa}
+If significant is greater than minimum, it defines the number of printed characters.
 \begin{cfa}[belowskip=0pt]
 sout | ws(3,6, 234567.) | ws(4,6, 234567.) | ws(5,6, 234567.) | ws(6,6, 234567.);
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @  @ 27.000000  27.500000  027  27.500@    @
+®  ® 27.000000  27.500000  027  27.500®    ®
 \end{cfa}
 …
 \begin{cfa}[belowskip=0pt]
 sout | pad0( wd( 4, 27 ) ) | pad0( wd( 4,3, 27 ) ) | pad0( wd( 8,3, 27.5 ) );
 @00@27  @0@27 @00@27.500
+®00®27  ®0®27 ®00®27.500
 \end{cfa}
 \end{enumerate}
 …
 The format of numeric input values in the same as C constants without a trailing type suffix, as the input value-type is denoted by the input variable.
 For ©_Bool© type, the constants are ©true© and ©false©.
+For ©bool© type, the constants are ©true© and ©false©.
 For integral types, any number of digits, optionally preceded by a sign (©+© or ©-©), where a
 \begin{itemize}
 …
 \begin{enumerate}
 \item
+\Indexc{skip( const char * pattern )}\index{manipulator!skip@©skip©} / ©skip( unsigned int length )© / ©const char * pattern©
+The argument defines a ©pattern© or ©length©.
+The ©pattern© is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character.
+The ©length© is composed of the next $N$ characters, including the newline character.
+\Indexc{skip}( pattern )\index{manipulator!skip@©skip©}, ©skip©( length )
+The pattern is composed of white-space and non-white-space characters, where \emph{any} white-space character matches 0 or more input white-space characters (hence, consecutive white-space characters in the pattern are combined), and each non-white-space character matches exactly with an input character.
+The length is composed of the next $N$ characters, including the newline character.
 If the match successes, the input characters are discarded, and input continues with the next character.
 If the match fails, the input characters are left unread.
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@abc   @
+@abc  @
+@xx@
 \end{cfa}
 \item
 \Indexc{wdi}©( unsigned int maximum, T & val )©\index{manipulator!wdi@©wdi©}
 For all types except ©char©, ©maximum© is the maximum number of characters read for the current operation.
+®abc   ®
+®abc  ®
+®xx®
+\end{cfa}
+\item
+\Indexc{wdi}( maximum, reference-value )\index{manipulator!wdi@©wdi©}
+For all types except ©char©, maximum is the maximum number of characters read for the current operation.
 \begin{cfa}[belowskip=0pt]
 char s[10];   int i;   double d;
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
+@abcd1233.456E+2@
+®abcd1233.456E+2®
 \end{cfa}
 Note, input ©wdi© cannot be overloaded with output ©wd© because both have the same parameters but return different types.
 …
 \item
 \Indexc{ignore( T & val )}\index{manipulator!ignore@©ignore©}
+\Indexc{ignore}( reference-value )\index{manipulator!ignore@©ignore©}
 For all types, the data is read from the stream depending on the argument type but ignored, \ie it is not stored in the argument.
 \begin{cfa}[belowskip=0pt]
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @  -75.35e-4@ 25
 \end{cfa}
 \item
 \Indexc{incl( const char * scanset, char * s )}\index{manipulator!incl@©incl©}
 For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{in} the set.
 Matching characters are read into the C string and null terminated.
+®  -75.35e-4® 25
+\end{cfa}
+\item
+\Indexc{incl}( scanset, input-string )\index{manipulator!incl@©incl©}
+For C-string types, the scanset matches any number of characters \emph{in} the set.
+Matching characters are read into the C input-string and null terminated.
 \begin{cfa}[belowskip=0pt]
 char s[10];
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @bca@xyz
 \end{cfa}
 \item
 \Indexc{excl( const char * scanset, char * s )}\index{manipulator!excl@©excl©}
 For the C-string type, the argument defines a ©scanset© that matches any number of characters \emph{not in} the set.
 Non-matching characters are read into the C string and null terminated.
+®bca®xyz
+\end{cfa}
+\item
+\Indexc{excl}( scanset, input-string )\index{manipulator!excl@©excl©}
+For C-string types, the scanset matches any number of characters \emph{not in} the set.
+Non-matching characters are read into the C input-string and null terminated.
 \begin{cfa}[belowskip=0pt]
 char s[10];
 …
 \end{cfa}
 \begin{cfa}[showspaces=true,aboveskip=0pt,belowskip=0pt]
 @xyz@bca
+®xyz®bca
 \end{cfa}
 \end{enumerate}
+\subsection{Concurrent Stream Access}
+When a stream is shared by multiple threads, input or output characters can be intermixed or cause failure.
+For example, if two threads execute the following:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : sout | "abc " | "def ";
+$\emph{thread\(_2\)}$ : sout | "uvw " | "xyz ";
+\end{cfa}
+possible outputs are:
+\begin{cquote}
+\begin{tabular}{@{}l|l|l|l|l@{}}
+\begin{cfa}
+abc def
+uvw xyz
+\end{cfa}
+&
+\begin{cfa}
+abc uvw xyz
+def
+\end{cfa}
+&
+\begin{cfa}
+uvw abc xyz def
+\end{cfa}
+&
+\begin{cfa}
+abuvwc dexf
+yz
+\end{cfa}
+&
+\begin{cfa}
+uvw abc def
+xyz
+\end{cfa}
+\end{tabular}
+\end{cquote}
+Concurrent operations can even corrupt the internal state of the stream resulting in failure.
+As a result, some form of mutual exclusion is required for concurrent stream access.
+A coarse-grained solution is to perform all stream operations via a single thread or within a monitor providing the necessary mutual exclusion for the stream.
+A fine-grained solution is to have a lock for each stream, which is acquired and released around stream operations by each thread.
+\CFA provides a fine-grained solution where a \Index{recursive lock} is acquired and released indirectly via a manipulator ©acquire© or instantiating an \Index{RAII} type specific for the kind of stream: ©osacquire©\index{ostream@©ostream©!osacquire@©osacquire©} for output streams and ©isacquire©\index{isacquire@©isacquire©}\index{istream@©istream©!isacquire@©isacquire©} for input streams.
+The common usage is manipulator ©acquire©\index{ostream@©ostream©!acquire@©acquire©} to lock a stream during a single cascaded I/O expression, with the manipulator appearing as the first item in a cascade list, \eg:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : sout | ®acquire® | "abc " | "def ";   // manipulator
+$\emph{thread\(_2\)}$ : sout | ®acquire® | "uvw " | "xyz ";
+\end{cfa}
+Now, the order of the thread execution is still non-deterministic, but the output is constrained to two possible lines in either order.
+\begin{cquote}
+\def\VRfont{\fontfamily{pcr}\upshape\selectfont}
+\begin{tabular}{@{}l|l@{}}
+\begin{cfa}
+abc def
+uvw xyz
+\end{cfa}
+&
+\begin{cfa}
+uvw xyz
+abc def
+\end{cfa}
+\end{tabular}
+\end{cquote}
+In summary, the stream lock is acquired by the ©acquire© manipulator and implicitly released at the end of the cascaded I/O expression ensuring all operations in the expression occur atomically.
+To lock a stream across multiple I/O operations, an object of type ©osacquire© or ©isacquire© is declared to implicitly acquire/release the stream lock providing mutual exclusion for the object's duration, \eg:
+\begin{cfa}
+{       // acquire sout for block duration
+        ®osacquire® acq = { sout };                             $\C{// named stream locker}$
+        sout | 1;
+        sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
+        sout | 4;
+}       // implicitly release the lock when "acq" is deallocated
+\end{cfa}
+Note, the unnecessary ©acquire© manipulator works because the recursive stream-lock can be acquired/released multiple times by the owner thread.
+Hence, calls to functions that also acquire a stream lock for their output do not result in \Index{deadlock}.
+The previous values written by threads 1 and 2 can be read in concurrently:
+\begin{cfa}
+{       // acquire sin lock for block duration
+        ®isacquire acq = { sin };®                              $\C{// named stream locker}$
+        int x, y, z, w;
+        sin | x;
+        sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
+        sin | w;
+}       // implicitly release the lock when "acq" is deallocated
+\end{cfa}
+Again, the order of the reading threads is non-deterministic.
+Note, non-deterministic reading is rare.
+\Textbf{WARNING:} The general problem of \Index{nested locking} can occur if routines are called in an I/O sequence that block, \eg:
+\begin{cfa}
+sout | ®acquire® | "data:" | rtn( mon );        $\C{// mutex call on monitor}$
+\end{cfa}
+If the thread executing the I/O expression blocks in the monitor with the ©sout© lock, other threads writing to ©sout© also block until the thread holding the lock is unblocked and releases it.
+This scenario can lead to \Index{deadlock}, if the thread that is going to unblock the thread waiting in the monitor first writes to ©sout© (deadly embrace).
+To prevent nested locking, a simple precaution is to factor out the blocking call from the expression, \eg:
+\begin{cfa}
+int ®data® = rtn( mon );
+sout | acquire | "data:" | ®data®;
+\end{cfa}
+\Textbf{WARNING:} ©printf©\index{printf@©printf©}, ©scanf©\index{scanf@©scanf©} and their derivatives are unsafe when used with user-level threading, as in \CFA.
+These stream routines use kernel-thread locking (©futex©\index{futex@©futex©}), which block kernel threads, to prevent interleaving of I/O.
+However, the following simple example illustrates how a deadlock can occur (other complex scenarios are possible).
+Assume a single kernel thread and two user-level threads calling ©printf©.
+One user-level thread acquires the I/O lock and is time-sliced while performing ©printf©.
+The other user-level thread then starts execution, calls ©printf©, and blocks the only kernel thread because it cannot acquire the I/O lock.
+It does not help if the kernel lock is multiple acquisition, \ie, the lock owner can acquire it multiple times, because it then results in two user threads in the ©printf© critical section, corrupting the stream.
+\begin{comment}
 \section{Types}
 …
 process((int) s); // type is converted, no function is called
 \end{cfa}
+\end{comment}
 …
 In C, the integer constants 0 and 1 suffice because the integer promotion rules can convert them to any arithmetic type, and the rules for pointer expressions treat constant expressions evaluating to 0 as a special case.
 However, user-defined arithmetic types often need the equivalent of a 1 or 0 for their functions or operators, polymorphic functions often need 0 and 1 constants of a type matching their polymorphic parameters, and user-defined pointer-like types may need a null value.
 Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©_Bool©.
+Defining special constants for a user-defined type is more efficient than defining a conversion to the type from ©bool©.
 Why just 0 and 1? Why not other integers? No other integers have special status in C.
 …
 \begin{table}[hbt]
 \centering
+\input{../refrat/operidents}
+\begin{tabular}{@{}l@{\hspace{\parindentlnth}}l@{\hspace{\parindentlnth}}l@{}}
+\begin{tabular}{@{}ll@{}}
+©?[?]©  & subscripting \impl{?[?]}                                      \\
+©?()©   & function call \impl{?()}                                      \\
+©?++©   & postfix increment \impl{?++}                          \\
+©?--©   & postfix decrement \impl{?--}                          \\
+©++?©   & prefix increment \impl{++?}                           \\
+©--?©   & prefix decrement \impl{--?}                           \\
+©*?©    & dereference \impl{*?}                                         \\
+©+?©    & unary plus \impl{+?}                                          \\
+©-?©    & arithmetic negation \impl{-?}                         \\
+©~?©    & bitwise negation \impl{~?}                            \\
+©!?©    & logical complement \impl{"!?}                         \\
+©?\?©   & exponentiation \impl{?\?}                                     \\
+©?*?©   & multiplication \impl{?*?}                                     \\
+©?/?©   & division \impl{?/?}                                           \\
+©?%?©   & remainder \impl{?%?}                                          \\
+\end{tabular}
+&
+\begin{tabular}{@{}ll@{}}
+©?+?©   & addition \impl{?+?}                                           \\
+©?-?©   & subtraction \impl{?-?}                                        \\
+©?<<?©  & left shift \impl{?<<?}                                        \\
+©?>>?©  & right shift \impl{?>>?}                                       \\
+©?<?©   & less than \impl{?<?}                                          \\
+©?<=?©  & less than or equal \impl{?<=?}                        \\
+©?>=?©  & greater than or equal \impl{?>=?}                     \\
+©?>?©   & greater than \impl{?>?}                                       \\
+©?==?©  & equality \impl{?==?}                                          \\
+©?!=?©  & inequality \impl{?"!=?}                                       \\
+©?&?©   & bitwise AND \impl{?&?}                                        \\
+©?^?©   & exclusive OR \impl{?^?}                                       \\
+©?|?©   & inclusive OR \impl{?"|?}                                      \\
+                                                                                                        \\
+                                                                                                        \\
+\end{tabular}
+&
+\begin{tabular}{@{}ll@{}}
+©?=?©   & simple assignment \impl{?=?}                          \\
+©?\=?©  & exponentiation assignment \impl{?\=?}         \\
+©?*=?©  & multiplication assignment \impl{?*=?}         \\
+©?/=?©  & division assignment \impl{?/=?}                       \\
+©?%=?©  & remainder assignment \impl{?%=?}                      \\
+©?+=?©  & addition assignment \impl{?+=?}                       \\
+©?-=?©  & subtraction assignment \impl{?-=?}            \\
+©?<<=?© & left-shift assignment \impl{?<<=?}            \\
+©?>>=?© & right-shift assignment \impl{?>>=?}           \\
+©?&=?©  & bitwise AND assignment \impl{?&=?}            \\
+©?^=?©  & exclusive OR assignment \impl{?^=?}           \\
+©?|=?©  & inclusive OR assignment \impl{?"|=?}          \\
+                                                                                                        \\
+                                                                                                        \\
+                                                                                                        \\
+\end{tabular}
+\end{tabular}
 \caption{Operator Identifiers}
 \label{opids}
 …
 For example, given
 \begin{cfa}
 auto j = @...@
+auto j = ®...®
 \end{cfa}
 and the need to write a routine to compute using ©j©
 \begin{cfa}
 void rtn( @...@ parm );
+void rtn( ®...® parm );
 rtn( j );
 \end{cfa}
 …
 \begin{figure}
 \begin{cfa}
 #include <fstream>
 #include <coroutine>
 coroutine Fibonacci {
+#include <fstream.hfa>
+#include ®<coroutine.hfa>®
+®coroutine® Fibonacci {
         int fn; $\C{// used for communication}$
 };
+void ?{}( Fibonacci * this ) {
+        this->fn = 0;
+}
+void main( Fibonacci * this ) {
+void main( Fibonacci & fib ) with( fib ) { $\C{// called on first resume}$
         int fn1, fn2; $\C{// retained between resumes}$
+        this->fn = 0; $\C{// case 0}$
+        fn1 = this->fn;
+        suspend(); $\C{// return to last resume}$
+        this->fn = 1; $\C{// case 1}$
+        fn2 = fn1;
+        fn1 = this->fn;
+        suspend(); $\C{// return to last resume}$
+        for ( ;; ) { $\C{// general case}$
+                this->fn = fn1 + fn2;
+                fn2 = fn1;
+                fn1 = this->fn;
+                suspend(); $\C{// return to last resume}$
+        } // for
+}
+int next( Fibonacci * this ) {
+        resume( this ); $\C{// transfer to last suspend}$
+        return this->fn;
+        fn = 0;  fn1 = fn; $\C{// 1st case}$
+        ®suspend;® $\C{// restart last resume}$
+        fn = 1;  fn2 = fn1;  fn1 = fn; $\C{// 2nd case}$
+        ®suspend;® $\C{// restart last resume}$
+        for () {
+                fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; $\C{// general case}$
+                ®suspend;® $\C{// restart last resume}$
+        }
+}
+int next( Fibonacci & fib ) with( fib ) {
+        ®resume( fib );® $\C{// restart last suspend}$
+        return fn;
+}
 int main() {
         Fibonacci f1, f2;
+        for ( int i = 1; i <= 10; i += 1 ) {
+                sout | next( &f1 ) | ' ' | next( &f2 );
+        } // for
+}
+\end{cfa}
+        for ( 10 ) { $\C{// print N Fibonacci values}$
+                sout | next( f1 ) | next( f2 );
+        }
+}
+\end{cfa}
+\vspace*{-5pt}
 \caption{Fibonacci Coroutine}
 \label{f:FibonacciCoroutine}
 …
 \begin{figure}
 \begin{cfa}
+#include <fstream>
+#include <kernel>
+#include <monitor>
+#include <thread>
+monitor global_t {
+        int value;
+};
+void ?{}(global_t * this) {
+        this->value = 0;
+}
+static global_t global;
+void increment3( global_t * mutex this ) {
+        this->value += 1;
+}
+void increment2( global_t * mutex this ) {
+        increment3( this );
+}
+void increment( global_t * mutex this ) {
+        increment2( this );
+}
+#include <fstream.hfa>
+#include ®<thread.hfa>®
+®monitor® AtomicCnt { int counter; };
+void ?{}( AtomicCnt & c, int init = 0 ) with(c) { counter = init; }
+int inc( AtomicCnt & ®mutex® c, int inc = 1 ) with(c) { return counter += inc; }
+int dec( AtomicCnt & ®mutex® c, int dec = 1 ) with(c) { return counter -= dec; }
+forall( ostype & | ostream( ostype ) ) { $\C{// print any stream}$
+        ostype & ?|?( ostype & os, AtomicCnt c ) { return os | c.counter; }
+        void ?|?( ostype & os, AtomicCnt c ) { (ostype &)(os | c.counter); ends( os ); }
+}
+AtomicCnt global; $\C{// shared}$
 thread MyThread {};
 void main( MyThread* this ) {
         for(int i = 0; i < 1_000_000; i++) {
                 increment( &global );
+void main( MyThread & ) {
+        for ( i; 100_000 ) {
+                inc( global );
+                dec( global );
+        }
+}
+int main(int argc, char* argv[]) {
+        processor p;
+int main() {
+        enum { Threads = 4 };
+        processor p[Threads - 1]; $\C{// + starting processor}$
+        {
                 MyThread f[4];
+                MyThread t[Threads];
+        }
         sout | global.value;
+        sout | global; $\C{// print 0}$
+}
 \end{cfa}
 \caption{Atomic-Counter Monitor}
 \caption{f:AtomicCounterMonitor}
+\label{f:AtomicCounterMonitor}
 \end{figure}
 …
 C has a number of syntax ambiguities, which are resolved by taking the longest sequence of overlapping characters that constitute a token.
 For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]@x ++ ++ + y@ because operator tokens ©++© and ©+© overlap.
 Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]@x ++ + ++ y@ might yield a correct expression.
+For example, the program fragment ©x+++++y© is parsed as \lstinline[showspaces=true]{x ++ ++ + y} because operator tokens ©++© and ©+© overlap.
+Unfortunately, the longest sequence violates a constraint on increment operators, even though the parse \lstinline[showspaces=true]{x ++ + ++ y} might yield a correct expression.
 Hence, C programmers are aware that spaces have to added to disambiguate certain syntactic cases.
 …
 requiring arbitrary whitespace look-ahead for the routine-call parameter-list to disambiguate.
 However, the dereference operator \emph{must} have a parameter/argument to dereference ©*?(...)©.
 Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]@* ?()@ does not preclude any meaningful program.
+Hence, always interpreting the string ©*?()© as \lstinline[showspaces=true]{* ?()} does not preclude any meaningful program.
 The remaining cases are with the increment/decrement operators and conditional expression, \eg:
 …
 \begin{cfa}
 int i; $\C{// forward definition}$
 int *j = @&i@; $\C{// forward reference, valid in C, invalid in \CFA}$
+int *j = ®&i®; $\C{// forward reference, valid in C, invalid in \CFA}$
 int i = 0; $\C{// definition}$
 \end{cfa}
 …
 struct X { int i; struct X *next; };
 static struct X a; $\C{// forward definition}$
 static struct X b = { 0, @&a@ };$\C{// forward reference, valid in C, invalid in \CFA}$
+static struct X b = { 0, ®&a® };$\C{// forward reference, valid in C, invalid in \CFA}$
 static struct X a = { 1, &b }; $\C{// definition}$
 \end{cfa}
 …
 \item[Change:] have ©struct© introduce a scope for nested types:
 \begin{cfa}
 enum @Colour@ { R, G, B, Y, C, M };
+enum ®Colour® { R, G, B, Y, C, M };
 struct Person {
         enum @Colour@ { R, G, B };      $\C[7cm]{// nested type}$
+        enum ®Colour® { R, G, B };      $\C[7cm]{// nested type}$
         struct Face { $\C{// nested type}$
                 @Colour@ Eyes, Hair; $\C{// type defined outside (1 level)}$
+                ®Colour® Eyes, Hair; $\C{// type defined outside (1 level)}$
         };
         @.Colour@ shirt; $\C{// type defined outside (top level)}$
         @Colour@ pants; $\C{// type defined same level}$
+        ®.Colour® shirt; $\C{// type defined outside (top level)}$
+        ®Colour® pants; $\C{// type defined same level}$
         Face looks[10]; $\C{// type defined same level}$
 };
 @Colour@ c = R; $\C{// type/enum defined same level}$
 Person@.Colour@ pc = Person@.@R;$\C{// type/enum defined inside}$
 Person@.@Face pretty; $\C{// type defined inside}\CRT$
+®Colour® c = R; $\C{// type/enum defined same level}$
+Person®.Colour® pc = Person®.®R;$\C{// type/enum defined inside}$
+Person®.®Face pretty; $\C{// type defined inside}\CRT$
 \end{cfa}
 In C, the name of the nested types belongs to the same scope as the name of the outermost enclosing structure, \ie the nested types are hoisted to the scope of the outer-most type, which is not useful and confusing.
 …
 \label{s:CFAKeywords}
 \CFA introduces the following new keywords.
+\CFA introduces the following new \Index{keyword}s, which cannot be used as identifiers.
 \begin{cquote}
+\input{../refrat/keywords}
+\begin{tabular}{@{}lllllll@{}}
+\begin{tabular}{@{}l@{}}
+\Indexc{basetypeof}             \\
+\Indexc{choose}                 \\
+\Indexc{coroutine}              \\
+\Indexc{disable}                \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{enable}                 \\
+\Indexc{exception}              \\
+\Indexc{fallthrough}    \\
+\Indexc{fallthru}               \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{finally}                \\
+\Indexc{fixup}                  \\
+\Indexc{forall}                 \\
+\Indexc{generator}              \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{int128}                 \\
+\Indexc{monitor}                \\
+\Indexc{mutex}                  \\
+\Indexc{one_t}                  \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{report}                 \\
+\Indexc{suspend}                \\
+\Indexc{throw}                  \\
+\Indexc{throwResume}    \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{trait}                  \\
+\Indexc{try}                    \\
+\Indexc{virtual}                \\
+\Indexc{waitfor}                \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{when}                   \\
+\Indexc{with}                   \\
+\Indexc{zero_t}                 \\
+                                                \\
+\end{tabular}
+\end{tabular}
 \end{cquote}
+\CFA introduces the following new \Index{quasi-keyword}s, which can be used as identifiers.
+\begin{cquote}
+\begin{tabular}{@{}ll@{}}
+\begin{tabular}{@{}l@{}}
+\Indexc{catch}                  \\
+\Indexc{catchResume}    \\
+\Indexc{finally}                \\
+\end{tabular}
+&
+\begin{tabular}{@{}l@{}}
+\Indexc{fixup}                  \\
+\Indexc{or}                             \\
+\Indexc{timeout}                \\
+\end{tabular}
+\end{tabular}
+\end{cquote}
 \section{Standard Headers}
 …
 // assume ?|? operator for printing an S
 S & sp = *@new@( 3 );                                                   $\C{// call constructor after allocation}$
+S & sp = *®new®( 3 );                                                   $\C{// call constructor after allocation}$
 sout | sp.i;
 @delete@( &sp );
 S * spa = @anew@( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
+®delete®( &sp );
+S * spa = ®anew®( 10, 5 );                                              $\C{// allocate array and initialize each array element}$
 for ( i; 10 ) sout | spa[i] | nonl;
 sout | nl;
 @adelete@( 10, spa );
+®adelete®( 10, spa );
 \end{cfa}
 Allocation routines ©new©/©anew© allocate a variable/array and initialize storage using the allocated type's constructor.
 …
 [ int, long double ] remquo( long double, long double );
-float div( float, float, int * );$\indexc{div}$ $\C{// alternative name for remquo}$
-double div( double, double, int * );
-long double div( long double, long double, int * );
 [ int, float ] div( float, float );
 [ int, double ] div( double, double );
 …
 long double _Complex log( long double _Complex );
+float log2( float );$\indexc{log2}$
+int log2( unsigned int );$\indexc{log2}$
+long int log2( unsigned long int );
+long long int log2( unsigned long long int )
+float log2( float );
 double log2( double );
 long double log2( long double );
 …
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+// n / align * align
+signed char floor( signed char n, signed char align );
+unsigned char floor( unsigned char n, unsigned char align );
+short int floor( short int n, short int align );
+unsigned short int floor( unsigned short int n, unsigned short int align );
+int floor( int n, int align );
+unsigned int floor( unsigned int n, unsigned int align );
+long int floor( long int n, long int align );
+unsigned long int floor( unsigned long int n, unsigned long int align );
+long long int floor( long long int n, long long int align );
+unsigned long long int floor( unsigned long long int n, unsigned long long int align );
+// (n + (align - 1)) / align
+signed char ceiling_div( signed char n, char align );
+unsigned char ceiling_div( unsigned char n, unsigned char align );
+short int ceiling_div( short int n, short int align );
+unsigned short int ceiling_div( unsigned short int n, unsigned short int align );
+int ceiling_div( int n, int align );
+unsigned int ceiling_div( unsigned int n, unsigned int align );
+long int ceiling_div( long int n, long int align );
+unsigned long int ceiling_div( unsigned long int n, unsigned long int align );
+long long int ceiling_div( long long int n, long long int align );
+unsigned long long int ceiling_div( unsigned long long int n, unsigned long long int align );
+// floor( n + (n % align != 0 ? align - 1 : 0), align )
+signed char ceiling( signed char n, signed char align );
+unsigned char ceiling( unsigned char n, unsigned char align );
+short int ceiling( short int n, short int align );
+unsigned short int ceiling( unsigned short int n, unsigned short int align );
+int ceiling( int n, int align );
+unsigned int ceiling( unsigned int n, unsigned int align );
+long int ceiling( long int n, long int align );
+unsigned long int ceiling( unsigned long int n, unsigned long int align );
+long long int ceiling( long long int n, long long int align );
+unsigned long long int ceiling( unsigned long long int n, unsigned long long int align );
 float floor( float );$\indexc{floor}$
 double floor( double );
 …
 %\subsection{\texorpdfstring{\protect\lstinline@Duration@}{Duration}}
+%\subsection{\texorpdfstring{\protect\lstinline{Duration}}{Duration}}
 \subsection{\texorpdfstring{\LstBasicStyle{Duration}}{Duration}}
 \label{s:Duration}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Duration {
         int64_t tv; $\C{// nanoseconds}$
+        int64_t tn; $\C{// nanoseconds}$
 };
 void ?{}( Duration & dur );
 void ?{}( Duration & dur, zero_t );
+void ?{}( Duration & dur, timeval t )
+void ?{}( Duration & dur, timespec t )
 Duration ?=?( Duration & dur, zero_t );
+Duration ?=?( Duration & dur, timeval t )
+Duration ?=?( Duration & dur, timespec t )
 Duration +?( Duration rhs );
 …
 Duration ?%=?( Duration & lhs, Duration rhs );
 _Bool ?==?( Duration lhs, Duration rhs );
 _Bool ?!=?( Duration lhs, Duration rhs );
 _Bool ?<? ( Duration lhs, Duration rhs );
 _Bool ?<=?( Duration lhs, Duration rhs );
 _Bool ?>? ( Duration lhs, Duration rhs );
 _Bool ?>=?( Duration lhs, Duration rhs );
 _Bool ?==?( Duration lhs, zero_t );
 _Bool ?!=?( Duration lhs, zero_t );
 _Bool ?<? ( Duration lhs, zero_t );
 _Bool ?<=?( Duration lhs, zero_t );
 _Bool ?>? ( Duration lhs, zero_t );
 _Bool ?>=?( Duration lhs, zero_t );
+bool ?==?( Duration lhs, zero_t );
+bool ?!=?( Duration lhs, zero_t );
+bool ?<? ( Duration lhs, zero_t );
+bool ?<=?( Duration lhs, zero_t );
+bool ?>? ( Duration lhs, zero_t );
+bool ?>=?( Duration lhs, zero_t );
+bool ?==?( Duration lhs, Duration rhs );
+bool ?!=?( Duration lhs, Duration rhs );
+bool ?<? ( Duration lhs, Duration rhs );
+bool ?<=?( Duration lhs, Duration rhs );
+bool ?>? ( Duration lhs, Duration rhs );
+bool ?>=?( Duration lhs, Duration rhs );
 Duration abs( Duration rhs );
 …
 int64_t ?`w( Duration dur );
+double ?`dns( Duration dur );
+double ?`dus( Duration dur );
+double ?`dms( Duration dur );
+double ?`ds( Duration dur );
+double ?`dm( Duration dur );
+double ?`dh( Duration dur );
+double ?`dd( Duration dur );
+double ?`dw( Duration dur );
 Duration max( Duration lhs, Duration rhs );
 Duration min( Duration lhs, Duration rhs );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline@\timeval@}{timeval}}
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Duration dur );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline{timeval}}{timeval}}
 \subsection{\texorpdfstring{\LstBasicStyle{timeval}}{timeval}}
 \label{s:timeval}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timeval & t );
+void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, time_t sec, suseconds_t usec );
 void ?{}( timeval & t, time_t sec );
-void ?{}( timeval & t, zero_t );
 void ?{}( timeval & t, Time time );
 …
 timeval ?+?( timeval & lhs, timeval rhs );
 timeval ?-?( timeval & lhs, timeval rhs );
 _Bool ?==?( timeval lhs, timeval rhs );
 _Bool ?!=?( timeval lhs, timeval rhs );
 \end{cfa}
 %\subsection{\texorpdfstring{\protect\lstinline@timespec@}{timespec}}
+bool ?==?( timeval lhs, timeval rhs );
+bool ?!=?( timeval lhs, timeval rhs );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline{timespec}}{timespec}}
 \subsection{\texorpdfstring{\LstBasicStyle{timespec}}{timespec}}
 \label{s:timespec}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 void ?{}( timespec & t );
+void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, time_t sec, __syscall_slong_t nsec );
 void ?{}( timespec & t, time_t sec );
-void ?{}( timespec & t, zero_t );
 void ?{}( timespec & t, Time time );
 …
 timespec ?+?( timespec & lhs, timespec rhs );
 timespec ?-?( timespec & lhs, timespec rhs );
 _Bool ?==?( timespec lhs, timespec rhs );
 _Bool ?!=?( timespec lhs, timespec rhs );
 \end{cfa}
 %\subsection{\texorpdfstring{\protect\lstinline@itimerval@}{itimerval}}
+bool ?==?( timespec lhs, timespec rhs );
+bool ?!=?( timespec lhs, timespec rhs );
+\end{cfa}
+%\subsection{\texorpdfstring{\protect\lstinline{itimerval}}{itimerval}}
 \subsection{\texorpdfstring{\LstBasicStyle{itimerval}}{itimerval}}
 \label{s:itimerval}
 …
 %\subsection{\texorpdfstring{\protect\lstinline@Time@}{Time}}
+%\subsection{\texorpdfstring{\protect\lstinline{Time}}{Time}}
 \subsection{\texorpdfstring{\LstBasicStyle{Time}}{Time}}
 \label{s:Time}
 …
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
 struct Time {
         uint64_t tv; $\C{// nanoseconds since UNIX epoch}$
+        uint64_t tn; $\C{// nanoseconds since UNIX epoch}$
 };
 void ?{}( Time & time );
 void ?{}( Time & time, zero_t );
+void ?{}( Time & time, timeval t );
+void ?{}( Time & time, timespec t );
 Time ?=?( Time & time, zero_t );
-void ?{}( Time & time, timeval t );
 Time ?=?( Time & time, timeval t );
-void ?{}( Time & time, timespec t );
 Time ?=?( Time & time, timespec t );
 …
 Time ?-?( Time lhs, Duration rhs );
 Time ?-=?( Time & lhs, Duration rhs );
+_Bool ?==?( Time lhs, Time rhs );
+_Bool ?!=?( Time lhs, Time rhs );
+_Bool ?<?( Time lhs, Time rhs );
+_Bool ?<=?( Time lhs, Time rhs );
+_Bool ?>?( Time lhs, Time rhs );
+_Bool ?>=?( Time lhs, Time rhs );
+bool ?==?( Time lhs, Time rhs );
+bool ?!=?( Time lhs, Time rhs );
+bool ?<?( Time lhs, Time rhs );
+bool ?<=?( Time lhs, Time rhs );
+bool ?>?( Time lhs, Time rhs );
+bool ?>=?( Time lhs, Time rhs );
+int64_t ?`ns( Time t );
 char * yy_mm_dd( Time time, char * buf );
+char * ?`ymd( Time time, char * buf ) { // short form
+        return yy_mm_dd( time, buf );
+} // ymd
+char * ?`ymd( Time time, char * buf ); // short form
 char * mm_dd_yy( Time time, char * buf );
+char * ?`mdy( Time time, char * buf ) { // short form
+        return mm_dd_yy( time, buf );
+} // mdy
+char * ?`mdy( Time time, char * buf ); // short form
 char * dd_mm_yy( Time time, char * buf );
+char * ?`dmy( Time time, char * buf ) { // short form
+        return dd_mm_yy( time, buf );;
+} // dmy
+char * ?`dmy( Time time, char * buf ); // short form
 size_t strftime( char * buf, size_t size, const char * fmt, Time time );
+forall( dtype ostype | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
+forall( ostype & | ostream( ostype ) ) ostype & ?|?( ostype & os, Time time );
 \end{cfa}
 …
 %\subsection{\texorpdfstring{\protect\lstinline@Clock@}{Clock}}
+%\subsection{\texorpdfstring{\protect\lstinline{Clock}}{Clock}}
 \subsection{\texorpdfstring{\LstBasicStyle{Clock}}{Clock}}
 \label{s:Clock}
 …
 \leavevmode
 \begin{cfa}[aboveskip=0pt,belowskip=0pt]
+struct Clock {
+        Duration offset; $\C{// for virtual clock: contains offset from real-time}$
+        int clocktype; $\C{// implementation only -1 (virtual), CLOCK\_REALTIME}$
+struct Clock { $\C{// virtual clock}$
+        Duration offset; $\C{// offset from computer real-time}$
 };
+void resetClock( Clock & clk );
+void resetClock( Clock & clk, Duration adj );
+void ?{}( Clock & clk );
+void ?{}( Clock & clk, Duration adj );
+Duration getResNsec(); $\C{// with nanoseconds}$
+Duration getRes(); $\C{// without nanoseconds}$
+Time getTimeNsec(); $\C{// with nanoseconds}$
+Time getTime(); $\C{// without nanoseconds}$
+Time getTime( Clock & clk );
+Time ?()( Clock & clk );
+timeval getTime( Clock & clk );
+tm getTime( Clock & clk );
+void ?{}( Clock & clk ); $\C{// create no offset}$
+void ?{}( Clock & clk, Duration adj ); $\C{// create with offset}$
+void reset( Clock & clk, Duration adj ); $\C{// change offset}$
+Duration resolutionHi(); $\C{// clock resolution in nanoseconds (fine)}$
+Duration resolution(); $\C{// clock resolution without nanoseconds (coarse)}$
+Time timeHiRes(); $\C{// real time with nanoseconds}$
+Time time(); $\C{// real time without nanoseconds}$
+Time time( Clock & clk ); $\C{// real time for given clock}$
+Time ?()( Clock & clk ); $\C{//\ \ \ \ alternative syntax}$
+timeval time( Clock & clk ); $\C{// convert to C time format}$
+tm time( Clock & clk );
+Duration processor(); $\C{// non-monotonic duration of kernel thread}$
+Duration program(); $\C{// non-monotonic duration of program CPU}$
+Duration boot(); $\C{// monotonic duration since computer boot}$
 \end{cfa}
 …
 forall( dtype ostype | ostream( ostype ) ) ostype * ?|?( ostype * os, Int mp );
 \end{cfa}
+The following factorial programs contrast using GMP with the \CFA and C interfaces, where the output from these programs appears in \VRef[Figure]{f:MultiPrecisionFactorials}.
+\VRef[Figure]{f:MultiPrecisionFactorials} shows \CFA and C factorial programs using the GMP interfaces.
 (Compile with flag \Indexc{-lgmp} to link with the GMP library.)
+\begin{figure}
 \begin{cquote}
 \begin{tabular}{@{}l@{\hspace{\parindentlnth}}|@{\hspace{\parindentlnth}}l@{}}
 \multicolumn{1}{c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}}    & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}}      \\
+\multicolumn{1}{@{}c|@{\hspace{\parindentlnth}}}{\textbf{\CFA}} & \multicolumn{1}{@{\hspace{\parindentlnth}}c}{\textbf{C}@{}}   \\
 \hline
 \begin{cfa}
 …
         sout | 0 | fact;
         for ( unsigned int i = 1; i <= 40; i += 1 ) {
+        for ( i; 40 ) {
                 fact *= i;
                 sout | i | fact;
 …
 #include <gmp.h>$\indexc{gmp.h}$
 int main( void ) {
         @gmp_printf@( "Factorial Numbers\n" );
         @mpz_t@ fact;
         @mpz_init_set_ui@( fact, 1 );
         @gmp_printf@( "%d %Zd\n", 0, fact );
+        ®gmp_printf®( "Factorial Numbers\n" );
+        ®mpz_t® fact;
+        ®mpz_init_set_ui®( fact, 1 );
+        ®gmp_printf®( "%d %Zd\n", 0, fact );
         for ( unsigned int i = 1; i <= 40; i += 1 ) {
                 @mpz_mul_ui@( fact, fact, i );
                 @gmp_printf@( "%d %Zd\n", i, fact );
+                ®mpz_mul_ui®( fact, fact, i );
+                ®gmp_printf®( "%d %Zd\n", i, fact );
+        }
+}
 …
 \end{tabular}
 \end{cquote}
+\begin{figure}
+\small
 \begin{cfa}
 Factorial Numbers

example/io/batch-readv.c

-              rfeacef9
+              r5407cdc
+}
 uint64_t getTimeNsec() {
+uint64_t timeHiRes() {
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
 …
         printf("Running for %f second, reading %d bytes in batches of %d\n", duration, buflen, batch);
         uint64_t start = getTimeNsec();
         uint64_t end   = getTimeNsec();
         uint64_t prev  = getTimeNsec();
+        uint64_t start = timeHiRes();
+        uint64_t end   = timeHiRes();
+        uint64_t prev  = timeHiRes();
         for(;;) {
                 submit_and_drain(&iov, batch);
                 end = getTimeNsec();
+                end = timeHiRes();
                 uint64_t delta = end - start;
                 if( to_fseconds(end - prev) > 0.1 ) {

libcfa/configure.ac

-              rfeacef9
+              r5407cdc
 AH_TEMPLATE([CFA_HAVE_IOSQE_FIXED_FILE],[Defined if io_uring support is present when compiling libcfathread and supports the flag FIXED_FILE.])
 AH_TEMPLATE([CFA_HAVE_IOSQE_IO_DRAIN],[Defined if io_uring support is present when compiling libcfathread and supports the flag IO_DRAIN.])
-AH_TEMPLATE([CFA_HAVE_IOSQE_ASYNC],[Defined if io_uring support is present when compiling libcfathread and supports the flag ASYNC.])
 AH_TEMPLATE([CFA_HAVE_IOSQE_IO_LINK],[Defined if io_uring support is present when compiling libcfathread and supports the flag IO_LINK.])
 AH_TEMPLATE([CFA_HAVE_IOSQE_IO_HARDLINK],[Defined if io_uring support is present when compiling libcfathread and supports the flag IO_HARDLINK.])
+AH_TEMPLATE([CFA_HAVE_IOSQE_ASYNC],[Defined if io_uring support is present when compiling libcfathread and supports the flag ASYNC.])
+AH_TEMPLATE([CFA_HAVE_IOSQE_BUFFER_SELECT],[Defined if io_uring support is present when compiling libcfathread and supports the flag BUFFER_SELEC.])
 AH_TEMPLATE([CFA_HAVE_SPLICE_F_FD_IN_FIXED],[Defined if io_uring support is present when compiling libcfathread and supports the flag SPLICE_F_FD_IN_FIXED.])
 AH_TEMPLATE([CFA_HAVE_IORING_SETUP_ATTACH_WQ],[Defined if io_uring support is present when compiling libcfathread and supports the flag IORING_SETUP_ATTACH_WQ.])
 …
 define(ioring_ops, [IORING_OP_NOP,IORING_OP_READV,IORING_OP_WRITEV,IORING_OP_FSYNC,IORING_OP_READ_FIXED,IORING_OP_WRITE_FIXED,IORING_OP_POLL_ADD,IORING_OP_POLL_REMOVE,IORING_OP_SYNC_FILE_RANGE,IORING_OP_SENDMSG,IORING_OP_RECVMSG,IORING_OP_TIMEOUT,IORING_OP_TIMEOUT_REMOVE,IORING_OP_ACCEPT,IORING_OP_ASYNC_CANCEL,IORING_OP_LINK_TIMEOUT,IORING_OP_CONNECT,IORING_OP_FALLOCATE,IORING_OP_OPENAT,IORING_OP_CLOSE,IORING_OP_FILES_UPDATE,IORING_OP_STATX,IORING_OP_READ,IORING_OP_WRITE,IORING_OP_FADVISE,IORING_OP_MADVISE,IORING_OP_SEND,IORING_OP_RECV,IORING_OP_OPENAT2,IORING_OP_EPOLL_CTL,IORING_OP_SPLICE,IORING_OP_PROVIDE_BUFFERS,IORING_OP_REMOVE_BUFFER,IORING_OP_TEE])
 define(ioring_flags, [IOSQE_FIXED_FILE,IOSQE_IO_DRAIN,IOSQE_ASYNC,IOSQE_IO_LINK,IOSQE_IO_HARDLINK,SPLICE_F_FD_IN_FIXED,IORING_SETUP_ATTACH_WQ])
+define(ioring_flags, [IOSQE_FIXED_FILE,IOSQE_IO_DRAIN,IOSQE_IO_LINK,IOSQE_IO_HARDLINK,IOSQE_ASYNC,IOSQE_BUFFER_SELECT,SPLICE_F_FD_IN_FIXED,IORING_SETUP_ATTACH_WQ])
 define(ioring_from_decls, [

libcfa/prelude/builtins.c

-              rfeacef9
+              r5407cdc
 // Author           : Peter A. Buhr
 // Created On       : Fri Jul 21 16:21:03 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Oct 27 14:42:00 2020
 // Update Count     : 111
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Tue Apr 13 17:26:32 2021
+// Update Count     : 117
 //
 …
 } // distribution
 #define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1
 #define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1)
+#define __CFA_BASE_COMP_1__() if ( x == 1 ) return 1
+#define __CFA_BASE_COMP_2__() if ( x == 2 ) return x << (y - 1)
 #define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0
 …
         __CFA_BASE_COMP_2__();                                                          /* special case, positive shifting for integral types */ \
         __CFA_EXP_OVERFLOW__();                                                         /* immediate overflow, negative exponent > 2^size-1 */ \
         typeof(ep) op = 1;                                                                      /* accumulate odd product */ \
+        typeof(x) op = 1;                                                                       /* accumulate odd product */ \
         for ( ; y > 1; y >>= 1 ) {                                                      /* squaring exponentiation, O(log2 y) */ \
                 if ( (y & 1) == 1 ) op = op * ep;                               /* odd ? */ \
                 ep = ep * ep; \
+                if ( (y & 1) == 1 ) op = op * x;                                /* odd ? */ \
+                x = x * x; \
         } \
         return ep * op
+        return x * op
 static inline {
+        long int ?\?( int ep, unsigned int y ) { __CFA_EXP__(); }
+        long int ?\?( long int ep, unsigned long int y ) { __CFA_EXP__(); }
+        long int ?\?( int x, unsigned int y ) { __CFA_EXP__(); }
+        long int ?\?( long int x, unsigned long int y ) { __CFA_EXP__(); }
+        long long int ?\?( long long int x, unsigned long long int y ) { __CFA_EXP__(); }
         // unsigned computation may be faster and larger
+        unsigned long int ?\?( unsigned int ep, unsigned int y ) { __CFA_EXP__(); }
+        unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { __CFA_EXP__(); }
+        unsigned long int ?\?( unsigned int x, unsigned int y ) { __CFA_EXP__(); }
+        unsigned long int ?\?( unsigned long int x, unsigned long int y ) { __CFA_EXP__(); }
+        unsigned long long int ?\?( unsigned long long int x, unsigned long long int y ) { __CFA_EXP__(); }
 } // distribution
 …
 static inline forall( OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) {
+        OT ?\?( OT ep, unsigned int y ) { __CFA_EXP__(); }
+        OT ?\?( OT ep, unsigned long int y ) { __CFA_EXP__(); }
+        OT ?\?( OT x, unsigned int y ) { __CFA_EXP__(); }
+        OT ?\?( OT x, unsigned long int y ) { __CFA_EXP__(); }
+        OT ?\?( OT x, unsigned long long int y ) { __CFA_EXP__(); }
 } // distribution
 …
 static inline {
+        long int ?\=?( int & x, unsigned int y ) { x = x \ y; return x; }
         long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
+        long long int ?\=?( long long int & x, unsigned long long int y ) { x = x \ y; return x; }
+        unsigned long int ?\=?( unsigned int & x, unsigned int y ) { x = x \ y; return x; }
         unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
+        int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
+        unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
+        unsigned long long int ?\=?( unsigned long long int & x, unsigned long long int y ) { x = x \ y; return x; }
 } // distribution

libcfa/prelude/defines.hfa.in

-              rfeacef9
+              r5407cdc
 /* Defined if io_uring support is present when compiling libcfathread and
+   supports the flag BUFFER_SELEC. */
+#undef CFA_HAVE_IOSQE_BUFFER_SELECT
+/* Defined if io_uring support is present when compiling libcfathread and
    supports the flag FIXED_FILE. */
 #undef CFA_HAVE_IOSQE_FIXED_FILE

libcfa/src/Makefile.am

-              rfeacef9
+              r5407cdc
 ## Created On       : Sun May 31 08:54:01 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Wed Dec  9 22:46:14 2020
 ## Update Count     : 250
+## Last Modified On : Sat Apr 24 09:09:56 2021
+## Update Count     : 254
 ###############################################################################
 …
         bits/queue.hfa \
         bits/sequence.hfa \
+        containers/array.hfa \
         concurrency/iofwd.hfa \
         containers/list.hfa \
+        containers/queueLockFree.hfa \
         containers/stackLockFree.hfa \
         vec/vec.hfa \
 …
         common.hfa \
         fstream.hfa \
+        strstream.hfa \
         heap.hfa \
         iostream.hfa \

libcfa/src/bits/debug.hfa

rfeacef9	r5407cdc
101	101	__CFADBG_PRINT_GROUP_##group(__cfaabi_bits_print_buffer(STDERR_FILENO, __VA_ARGS__))
102	102	#define __cfadbg_print_buffer_decl(group, ...) \
103		__CFADBG_PRINT_GROUP_##group(char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( __dbg_text, __dbg_len ))
	103	__CFADBG_PRINT_GROUP_##group(char __dbg_text[256]; int __dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write( STDERR_FILENO, __dbg_text, __dbg_len ))
104	104	#define __cfadbg_print_buffer_local(group, ...) \
105	105	__CFADBG_PRINT_GROUP_##group(__dbg_len = snprintf( __dbg_text, 256, __VA_ARGS__ ); __cfaabi_bits_write(STDERR_FILENO, __dbg_text, __dbg_len))

libcfa/src/bits/defs.hfa

rfeacef9	r5407cdc
74	74	#error unsupported architecture
75	75	#endif
	76
	77	#define CFA_IO_LAZY (1_l64u << 32_l64u)

libcfa/src/bits/locks.hfa

-              rfeacef9
+              r5407cdc
         extern "C" {
                 extern void disable_interrupts() OPTIONAL_THREAD;
                 extern void enable_interrupts_noPoll() OPTIONAL_THREAD;
+                extern void enable_interrupts( bool poll = true ) OPTIONAL_THREAD;
                 #ifdef __CFA_DEBUG__
 …
                         __cfaabi_dbg_record_lock( this, caller );
                 } else {
                         enable_interrupts_noPoll();
+                        enable_interrupts( false );
+                }
                 return result;
 …
         static inline void unlock( __spinlock_t & this ) {
                 __atomic_clear( &this.lock, __ATOMIC_RELEASE );
                 enable_interrupts_noPoll();
+                enable_interrupts( false );
+        }
 #endif

libcfa/src/bits/queue.hfa

-              rfeacef9
+              r5407cdc
         };
         inline {
+        static inline {
                 // wrappers to make Collection have T
                 T & head( Queue(T) & q ) with( q ) {
 …
         struct QueueIter {
                 inline ColIter;                                                                 // Plan 9 inheritance
         };
+        };
         inline {
+        static inline {
                 void ?{}( QueueIter(T) & qi ) with( qi ) {
                         ((ColIter &)qi){};

libcfa/src/bits/weakso_locks.cfa

-              rfeacef9
+              r5407cdc
 #include "bits/weakso_locks.hfa"
 void  ?{}( blocking_lock & this, bool multi_acquisition, bool strict_owner ) {}
 void ^?{}( blocking_lock & this ) {}
+void  ?{}( blocking_lock &, bool, bool ) {}
+void ^?{}( blocking_lock & ) {}
+void lock( blocking_lock & this ) {}
+bool try_lock( blocking_lock & this ) { return false; }
+void unlock( blocking_lock & this ) {}
+void on_notify( blocking_lock & this, struct $thread * t ) {}
+void on_wait( blocking_lock & this ) {}
+size_t wait_count( blocking_lock & this ) { return 0; }
+void set_recursion_count( blocking_lock & this, size_t recursion ) {}
+size_t get_recursion_count( blocking_lock & this ) { return 0; }
+void lock( blocking_lock & ) {}
+bool try_lock( blocking_lock & ) { return false; }
+void unlock( blocking_lock & ) {}
+void on_notify( blocking_lock &, struct $thread * ) {}
+size_t on_wait( blocking_lock & ) { return 0; }
+void on_wakeup( blocking_lock &, size_t ) {}
+size_t wait_count( blocking_lock & ) { return 0; }

libcfa/src/bits/weakso_locks.hfa

-              rfeacef9
+              r5407cdc
 void unlock( blocking_lock & this ) OPTIONAL_THREAD;
 void on_notify( blocking_lock & this, struct $thread * t ) OPTIONAL_THREAD;
+void on_wait( blocking_lock & this ) OPTIONAL_THREAD;
+size_t on_wait( blocking_lock & this ) OPTIONAL_THREAD;
+void on_wakeup( blocking_lock & this, size_t ) OPTIONAL_THREAD;
 size_t wait_count( blocking_lock & this ) OPTIONAL_THREAD;
-void set_recursion_count( blocking_lock & this, size_t recursion ) OPTIONAL_THREAD;
-size_t get_recursion_count( blocking_lock & this ) OPTIONAL_THREAD;
 //----------
 …
 static inline void  ?{}( multiple_acquisition_lock & this ) {((blocking_lock &)this){ true, false };}
 static inline void ^?{}( multiple_acquisition_lock & this ) {}
+static inline void   lock     ( multiple_acquisition_lock & this ) { lock   ( (blocking_lock &)this ); }
+static inline void   unlock   ( multiple_acquisition_lock & this ) { unlock ( (blocking_lock &)this ); }
+static inline void   on_wait  ( multiple_acquisition_lock & this ) { on_wait( (blocking_lock &)this ); }
+static inline void   lock     ( multiple_acquisition_lock & this ) { lock    ( (blocking_lock &)this ); }
+static inline bool   try_lock ( multiple_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
+static inline void   unlock   ( multiple_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
+static inline size_t on_wait  ( multiple_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
+static inline void   on_wakeup( multiple_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
 static inline void   on_notify( multiple_acquisition_lock & this, struct $thread * t ){ on_notify( (blocking_lock &)this, t ); }
-static inline void   set_recursion_count( multiple_acquisition_lock & this, size_t recursion ){ set_recursion_count( (blocking_lock &)this, recursion ); }
-static inline size_t get_recursion_count( multiple_acquisition_lock & this ){ return get_recursion_count( (blocking_lock &)this ); }

libcfa/src/clock.hfa

-              rfeacef9
+              r5407cdc
 // Created On       : Thu Apr 12 14:36:06 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan  6 12:49:58 2020
 // Update Count     : 9
+// Last Modified On : Sun Apr 18 08:12:16 2021
+// Update Count     : 28
 //
 …
 //######################### Clock #########################
+struct Clock {                                                                                  // private
+        Duration offset;                                                                        // for virtual clock: contains offset from real-time
+struct Clock {                                                                                  // virtual clock
+        // private
+        Duration offset;                                                                        // offset from computer real-time
 };
 static inline {
         void resetClock( Clock & clk, Duration adj ) with( clk ) {
+        void reset( Clock & clk, Duration adj ) with( clk ) { // change offset
                 offset = adj + __timezone`s;                                    // timezone (global) is (UTC - local time) in seconds
         } // resetClock
+        } // reset
+        void ?{}( Clock & clk, Duration adj ) { resetClock( clk, adj ); }
+        void ?{}( Clock & clk ) { reset( clk, (Duration){ 0 } ); } // create no offset
+        void ?{}( Clock & clk, Duration adj ) { reset( clk, adj ); } // create with offset
+        Duration getResNsec() {
+        // System-wide clock that measures real, i.e., wall-clock) time. This clock is affected by discontinuous jumps in
+        // the system time. For example, manual changes of the clock, and incremental adjustments performed by adjtime(3)
+        // and NTP (daylight saving (Fall back).
+        Duration resolutionHi() {                                                       // clock resolution in nanoseconds (fine)
                 struct timespec res;
                 clock_getres( CLOCK_REALTIME, &res );
                 return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
         } // getRes
+        } // resolutionHi
         Duration getRes() {
+        Duration resolution() {                                                         // clock resolution without nanoseconds (coarse)
                 struct timespec res;
                 clock_getres( CLOCK_REALTIME_COARSE, &res );
                 return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
         } // getRes
+        } // resolution
         Time getTimeNsec() {                                                            // with nanoseconds
+        Time timeHiRes() {                                                                      // real time with nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME, &curr );
                 return (Time){ curr };
         } // getTimeNsec
+        } // timeHiRes
         Time getTime() {                                                                        // without nanoseconds
+        Time time() {                                                                           // real time without nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME_COARSE, &curr );
                 curr.tv_nsec = 0;
                 return (Time){ curr };
         } // getTime
+        } // time
         Time getTime( Clock & clk ) with( clk ) {
                 return getTime() + offset;
         } // getTime
+        Time time( Clock & clk ) with( clk ) {                          // real time for given clock
+                return time() + offset;
+        } // time
         Time ?()( Clock & clk ) with( clk ) {                           // alternative syntax
                 return getTime() + offset;
         } // getTime
+                return time() + offset;
+        } // ?()
         timeval getTime( Clock & clk ) {
+        timeval time( Clock & clk ) {                                           // convert to C time format
                 return (timeval){ clk() };
         } // getTime
+        } // time
         tm getTime( Clock & clk ) with( clk ) {
+        tm time( Clock & clk ) with( clk ) {
                 tm ret;
                 localtime_r( getTime( clk ).tv_sec, &ret );
+                localtime_r( time( clk ).tv_sec, &ret );
                 return ret;
         } // getTime
+        } // time
+        Time getCPUTime() {
+        // CFA processor CPU-time watch that ticks when the processor (kernel thread) is running. This watch is affected by
+        // discontinuous jumps when the OS is not running the kernal thread. A duration is returned because the value is
+        // relative and cannot be converted to real-time (wall-clock) time.
+        Duration processor() {                                                          // non-monotonic duration of kernel thread
                 timespec ts;
                 clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
+                return (Time){ ts };
+    } // getCPUTime
+                return (Duration){ ts };
+        } // processor
+        // Program CPU-time watch measures CPU time consumed by all processors (kernel threads) in the UNIX process.  This
+        // watch is affected by discontinuous jumps when the OS is not running the kernel threads. A duration is returned
+        // because the value is relative and cannot be converted to real-time (wall-clock) time.
+        Duration program() {                                                            // non-monotonic duration of program CPU
+                timespec ts;
+                clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &ts );
+                return (Duration){ ts };
+        } // program
+        // Monotonic duration from machine boot and including system suspension. This watch is unaffected by discontinuous
+        // jumps resulting from manual changes of the clock, and incremental adjustments performed by adjtime(3) and NTP
+        // (Fall back). A duration is returned because the value is relative and cannot be converted to real-time
+        // (wall-clock) time.
+        Duration boot() {                                                                       // monotonic duration since computer boot
+                timespec ts;
+                clock_gettime( CLOCK_BOOTTIME, &ts );
+                return (Duration){ ts };
+        } // boot
 } // distribution

libcfa/src/concurrency/alarm.cfa

-              rfeacef9
+              r5407cdc
 #define __cforall_thread__
+// #define __CFA_DEBUG_PRINT_PREEMPTION__
 #include <errno.h>
 …
                 bool first = ! & alarms`first;
+                __cfadbg_print_safe( preemption, " KERNEL: alarm inserting %p (%lu).\n", this, this->alarm.tn );
                 insert( &alarms, this );
                 if( first ) {
 …
         unlock( event_kernel->lock );
         this->set = true;
         enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
+}
 …
+        }
         unlock( event_kernel->lock );
         enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
         this->set = false;
+}

libcfa/src/concurrency/clib/cfathread.cfa

-              rfeacef9
+              r5407cdc
 //
+#include "fstream.hfa"
+#include "locks.hfa"
 #include "kernel.hfa"
+#include "stats.hfa"
 #include "thread.hfa"
+thread CRunner {
+        void (*themain)( CRunner * );
+#include "time.hfa"
+#include "cfathread.h"
+extern void ?{}(processor &, const char[], cluster &, $thread *);
+extern "C" {
+      extern void __cfactx_invoke_thread(void (*main)(void *), void * this);
+}
+//================================================================================
+// Thread run y the C Interface
+struct cfathread_object {
+        $thread self;
+        void * (*themain)( void * );
+        void * arg;
+        void * ret;
 };
+static void ?{}( CRunner & this, void (*themain)( CRunner * ) ) {
+void main(cfathread_object & this);
+void ^?{}(cfathread_object & mutex this);
+static inline $thread * get_thread( cfathread_object & this ) { return &this.self; }
+typedef ThreadCancelled(cfathread_object) cfathread_exception;
+typedef ThreadCancelled_vtable(cfathread_object) cfathread_vtable;
+void defaultResumptionHandler(ThreadCancelled(cfathread_object) & except) {
+        abort | "A thread was cancelled";
+}
+cfathread_vtable _cfathread_vtable_instance;
+cfathread_vtable & const _default_vtable = _cfathread_vtable_instance;
+cfathread_vtable const & get_exception_vtable(cfathread_exception *) {
+        return _cfathread_vtable_instance;
+}
+static void ?{}( cfathread_object & this, cluster & cl, void *(*themain)( void * ), void * arg ) {
         this.themain = themain;
+}
+void main( CRunner & this ) {
+        this.themain( &this );
+}
+processor * procs = 0p;
+int proc_cnt = 1;
+        this.arg = arg;
+        (this.self){"C-thread", cl};
+        __thrd_start(this, main);
+}
+void ^?{}(cfathread_object & mutex this) {
+        ^(this.self){};
+}
+void main( cfathread_object & this ) {
+        __attribute__((unused)) void * const thrd_obj = (void*)&this;
+        __attribute__((unused)) void * const thrd_hdl = (void*)active_thread();
+        /* paranoid */ verify( thrd_obj == thrd_hdl );
+        this.ret = this.themain( this.arg );
+}
+//================================================================================
+// Special Init Thread responsible for the initialization or processors
+struct __cfainit {
+        $thread self;
+        void (*init)( void * );
+        void * arg;
+};
+void main(__cfainit & this);
+void ^?{}(__cfainit & mutex this);
+static inline $thread * get_thread( __cfainit & this ) { return &this.self; }
+typedef ThreadCancelled(__cfainit) __cfainit_exception;
+typedef ThreadCancelled_vtable(__cfainit) __cfainit_vtable;
+void defaultResumptionHandler(ThreadCancelled(__cfainit) & except) {
+        abort | "The init thread was cancelled";
+}
+__cfainit_vtable ___cfainit_vtable_instance;
+__cfainit_vtable const & get_exception_vtable(__cfainit_exception *) {
+        return ___cfainit_vtable_instance;
+}
+static void ?{}( __cfainit & this, void (*init)( void * ), void * arg ) {
+        this.init = init;
+        this.arg = arg;
+        (this.self){"Processir Init"};
+        // Don't use __thrd_start! just prep the context manually
+        $thread * this_thrd = get_thread(this);
+        void (*main_p)(__cfainit &) = main;
+        disable_interrupts();
+        __cfactx_start(main_p, get_coroutine(this), this, __cfactx_invoke_thread);
+        this_thrd->context.[SP, FP] = this_thrd->self_cor.context.[SP, FP];
+        /* paranoid */ verify( this_thrd->context.SP );
+        this_thrd->state = Ready;
+        enable_interrupts();
+}
+void ^?{}(__cfainit & mutex this) {
+        ^(this.self){};
+}
+void main( __cfainit & this ) {
+        __attribute__((unused)) void * const thrd_obj = (void*)&this;
+        __attribute__((unused)) void * const thrd_hdl = (void*)active_thread();
+        /* paranoid */ verify( thrd_obj == thrd_hdl );
+        this.init( this.arg );
+}
+//================================================================================
+// Main Api
 extern "C" {
+        //--------------------
+        // Basic thread management
+        CRunner * cfathread_create( void (*main)( CRunner * ) ) {
+                return new( main );
+        }
+        void cfathread_join( CRunner * thrd ) {
+                delete( thrd );
+        int cfathread_cluster_create(cfathread_cluster_t * cl) __attribute__((nonnull(1))) {
+                *cl = new();
+                return 0;
+        }
+        cfathread_cluster_t cfathread_cluster_self(void) {
+                return active_cluster();
+        }
+        int cfathread_cluster_print_stats( cfathread_cluster_t cl ) {
+                #if !defined(__CFA_NO_STATISTICS__)
+                        print_stats_at_exit( *cl, CFA_STATS_READY_Q | CFA_STATS_IO );
+                        print_stats_now( *cl, CFA_STATS_READY_Q | CFA_STATS_IO );
+                #endif
+                return 0;
+        }
+        int cfathread_cluster_add_worker(cfathread_cluster_t cl, pthread_t* tid, void (*init_routine) (void *), void * arg) {
+                __cfainit * it = 0p;
+                if(init_routine) {
+                        it = alloc();
+                        (*it){init_routine, arg};
+                }
+                processor * proc = alloc();
+                (*proc){ "C-processor", *cl, get_thread(*it) };
+                // Wait for the init thread to return before continuing
+                if(it) {
+                        ^(*it){};
+                        free(it);
+                }
+                if(tid) *tid = proc->kernel_thread;
+                return 0;
+        }
+        int cfathread_cluster_pause (cfathread_cluster_t) {
+                abort | "Pausing clusters is not supported";
+                exit(1);
+        }
+        int cfathread_cluster_resume(cfathread_cluster_t) {
+                abort | "Resuming clusters is not supported";
+                exit(1);
+        }
+        //--------------------
+        // Thread attributes
+        int cfathread_attr_init(cfathread_attr_t *attr) __attribute__((nonnull (1))) {
+                attr->cl = active_cluster();
+                return 0;
+        }
+        //--------------------
+        // Thread
+        int cfathread_create( cfathread_t * handle, const cfathread_attr_t * attr, void *(*main)( void * ), void * arg ) __attribute__((nonnull (1))) {
+                cluster * cl = attr ? attr->cl : active_cluster();
+                cfathread_t thrd = alloc();
+                (*thrd){ *cl, main, arg };
+                *handle = thrd;
+                return 0;
+        }
+        int cfathread_join( cfathread_t thrd, void ** retval ) {
+                void * ret = join( *thrd ).ret;
+                ^( *thrd ){};
+                free(thrd);
+                if(retval) {
+                        *retval = ret;
+                }
+                return 0;
+        }
+        int cfathread_get_errno(void) {
+                return errno;
+        }
+        cfathread_t cfathread_self(void) {
+                return (cfathread_t)active_thread();
+        }
+        int cfathread_usleep(useconds_t usecs) {
+                sleep(usecs`us);
+                return 0;
+        }
+        int cfathread_sleep(unsigned int secs) {
+                sleep(secs`s);
+                return 0;
+        }
 …
+        }
         void cfathread_unpark( CRunner * thrd ) {
+        void cfathread_unpark( cfathread_t thrd ) {
                 unpark( *thrd );
+        }
 …
+        }
+        //--------------------
+        // Basic kernel features
+        void cfathread_setproccnt( int ncnt ) {
+                assert( ncnt >= 1 );
+                adelete( procs );
+                proc_cnt = ncnt - 1;
+                procs = anew(proc_cnt);
+        }
+}
+        typedef struct cfathread_mutex * cfathread_mutex_t;
+        //--------------------
+        // Mutex
+        struct cfathread_mutex {
+                fast_lock impl;
+        };
+        int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict) __attribute__((nonnull (1))) { *mut = new(); return 0; }
+        int cfathread_mutex_destroy(cfathread_mutex_t *mut) __attribute__((nonnull (1))) { delete( *mut ); return 0; }
+        int cfathread_mutex_lock   (cfathread_mutex_t *mut) __attribute__((nonnull (1))) { lock( (*mut)->impl ); return 0; }
+        int cfathread_mutex_unlock (cfathread_mutex_t *mut) __attribute__((nonnull (1))) { unlock( (*mut)->impl ); return 0; }
+        int cfathread_mutex_trylock(cfathread_mutex_t *mut) __attribute__((nonnull (1))) {
+                bool ret = try_lock( (*mut)->impl );
+                if( ret ) return 0;
+                else return EBUSY;
+        }
+        //--------------------
+        // Condition
+        struct cfathread_condition {
+                condition_variable(fast_lock) impl;
+        };
+        int cfathread_cond_init(cfathread_cond_t *restrict cond, const cfathread_condattr_t *restrict) __attribute__((nonnull (1))) { *cond = new(); return 0; }
+        int cfathread_cond_signal(cfathread_cond_t *cond) __attribute__((nonnull (1)))  { notify_one( (*cond)->impl ); return 0; }
+        int cfathread_cond_wait(cfathread_cond_t *restrict cond, cfathread_mutex_t *restrict mut) __attribute__((nonnull (1,2))) { wait( (*cond)->impl, (*mut)->impl ); return 0; }
+        int cfathread_cond_timedwait(cfathread_cond_t *restrict cond, cfathread_mutex_t *restrict mut, const struct timespec *restrict abstime) __attribute__((nonnull (1,2,3))) {
+                Time t = { *abstime };
+                if( wait( (*cond)->impl, (*mut)->impl, t ) ) {
+                        return 0;
+                }
+                errno = ETIMEDOUT;
+                return ETIMEDOUT;
+        }
+}
+#include <iofwd.hfa>
+extern "C" {
+        #include <unistd.h>
+        #include <sys/types.h>
+        #include <sys/socket.h>
+        //--------------------
+        // IO operations
+        int cfathread_socket(int domain, int type, int protocol) {
+                return socket(domain, type, protocol);
+        }
+        int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len) {
+                return bind(socket, address, address_len);
+        }
+        int cfathread_listen(int socket, int backlog) {
+                return listen(socket, backlog);
+        }
+        int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len) {
+                return cfa_accept4(socket, address, address_len, 0, CFA_IO_LAZY);
+        }
+        int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len) {
+                return cfa_connect(socket, address, address_len, CFA_IO_LAZY);
+        }
+        int cfathread_dup(int fildes) {
+                return dup(fildes);
+        }
+        int cfathread_close(int fildes) {
+                return cfa_close(fildes, CFA_IO_LAZY);
+        }
+        ssize_t cfathread_sendmsg(int socket, const struct msghdr *message, int flags) {
+                return cfa_sendmsg(socket, message, flags, CFA_IO_LAZY);
+        }
+        ssize_t cfathread_write(int fildes, const void *buf, size_t nbyte) {
+                // Use send rather then write for socket since it's faster
+                return cfa_send(fildes, buf, nbyte, 0, CFA_IO_LAZY);
+        }
+        ssize_t cfathread_recvfrom(int socket, void *restrict buffer, size_t length, int flags, struct sockaddr *restrict address, socklen_t *restrict address_len)  {
+                struct iovec iov;
+                iov.iov_base = buffer;
+                iov.iov_len = length;
+                struct msghdr msg;
+                msg.msg_name = address;
+                msg.msg_namelen = address_len ? (socklen_t)*address_len : (socklen_t)0;
+                msg.msg_iov = &iov;
+                msg.msg_iovlen = 1;
+                msg.msg_control = 0p;
+                msg.msg_controllen = 0;
+                ssize_t ret = cfa_recvmsg(socket, &msg, flags, CFA_IO_LAZY);
+                if(address_len) *address_len = msg.msg_namelen;
+                return ret;
+        }
+        ssize_t cfathread_read(int fildes, void *buf, size_t nbyte) {
+                // Use recv rather then read for socket since it's faster
+                return cfa_recv(fildes, buf, nbyte, 0, CFA_IO_LAZY);
+        }
+}

libcfa/src/concurrency/clib/cfathread.h

-              rfeacef9
+              r5407cdc
 //
-#include "stddef.h"
-#include "invoke.h"
 #if defined(__cforall) || defined(__cplusplus)
 extern "C" {
 #endif
+        #include <asm/types.h>
+        #include <errno.h>
+        #include <unistd.h>
         //--------------------
         // Basic types
+        struct cfathread_CRunner_t;
+        typedef struct cfathread_CRunner_t * cfathread_t;
+        typedef struct cluster * cfathread_cluster_t;
+        int cfathread_cluster_create(cfathread_cluster_t * cluster);
+        cfathread_cluster_t cfathread_cluster_self(void);
+        int cfathread_cluster_print_stats(cfathread_cluster_t cluster);
+        int cfathread_cluster_add_worker(cfathread_cluster_t cluster, pthread_t* tid, void (*init_routine) (void *), void * arg);
+        int cfathread_cluster_pause (cfathread_cluster_t cluster);
+        int cfathread_cluster_resume(cfathread_cluster_t cluster);
         //--------------------
+        // Basic thread support
+        cfathread_t cfathread_create( void (*main)( cfathread_t ) );
+        void cfathread_join( cfathread_t );
+        // thread attribute
+        typedef struct cfathread_attr {
+                cfathread_cluster_t cl;
+        } cfathread_attr_t;
+        int cfathread_attr_init(cfathread_attr_t * attr) __attribute__((nonnull (1)));
+        static inline int cfathread_attr_destroy(cfathread_attr_t * attr) __attribute__((nonnull (1)));
+        static inline int cfathread_attr_destroy(cfathread_attr_t * attr) { return 0; }
+        static inline int cfathread_attr_setbackground(cfathread_attr_t * attr, int background) __attribute__((nonnull (1)));
+        static inline int cfathread_attr_setbackground(cfathread_attr_t * attr, int background) { return 0; }
+        static inline int cfathread_attr_setcluster(cfathread_attr_t * attr, cfathread_cluster_t cl) __attribute__((nonnull (1)));
+        static inline int cfathread_attr_setcluster(cfathread_attr_t * attr, cfathread_cluster_t cl) { attr->cl = cl; return 0; }
+        //--------------------
+        // thread type
+        struct cfathread_object;
+        typedef struct cfathread_object * cfathread_t;
+        int cfathread_create( cfathread_t * h, const cfathread_attr_t * a, void *(*main)( void * ), void * arg ) __attribute__((nonnull (1)));
+        int cfathread_join( cfathread_t, void ** retval );
+        int cfathread_get_errno(void);
+        cfathread_t cfathread_self(void);
+        int cfathread_usleep(useconds_t usecs);
+        int cfathread_sleep(unsigned int secs);
         void cfathread_park( void );
 …
         //--------------------
         // Basic kernel features
         void cfathread_setproccnt( int );
+        // mutex and condition
+        struct timespec;
+        typedef struct cfathread_mutex_attr {
+        } cfathread_mutexattr_t;
+        typedef struct cfathread_mutex * cfathread_mutex_t;
+        int cfathread_mutex_init(cfathread_mutex_t *restrict mut, const cfathread_mutexattr_t *restrict attr) __attribute__((nonnull (1)));
+        int cfathread_mutex_destroy(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
+        int cfathread_mutex_lock(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
+        int cfathread_mutex_trylock(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
+        int cfathread_mutex_unlock(cfathread_mutex_t *mut) __attribute__((nonnull (1)));
+        typedef struct cfathread_cond_attr {
+        } cfathread_condattr_t;
+        typedef struct cfathread_condition * cfathread_cond_t;
+        int cfathread_cond_init(cfathread_cond_t *restrict cond, const cfathread_condattr_t *restrict attr) __attribute__((nonnull (1)));
+        int cfathread_cond_wait(cfathread_cond_t *restrict cond, cfathread_mutex_t *restrict mut) __attribute__((nonnull (1,2)));
+        int cfathread_cond_timedwait(cfathread_cond_t *restrict cond, cfathread_mutex_t *restrict mut, const struct timespec *restrict abstime) __attribute__((nonnull (1,2,3)));
+        int cfathread_cond_signal(cfathread_cond_t *cond) __attribute__((nonnull (1)));
+        //--------------------
+        // IO operations
+        struct sockaddr;
+        struct msghdr;
+        int cfathread_socket(int domain, int type, int protocol);
+        int cfathread_bind(int socket, const struct sockaddr *address, socklen_t address_len);
+        int cfathread_listen(int socket, int backlog);
+        int cfathread_accept(int socket, struct sockaddr *restrict address, socklen_t *restrict address_len);
+        int cfathread_connect(int socket, const struct sockaddr *address, socklen_t address_len);
+        int cfathread_dup(int fildes);
+        int cfathread_close(int fildes);
+        ssize_t cfathread_sendmsg(int socket, const struct msghdr *message, int flags);
+        ssize_t cfathread_write(int fildes, const void *buf, size_t nbyte);
+        ssize_t cfathread_recvfrom(int socket, void *restrict buffer, size_t length, int flags, struct sockaddr *restrict address, socklen_t *restrict address_len);
+        ssize_t cfathread_read(int fildes, void *buf, size_t nbyte);
 #if defined(__cforall) || defined(__cplusplus)

libcfa/src/concurrency/coroutine.cfa

-              rfeacef9
+              r5407cdc
 //-----------------------------------------------------------------------------
-FORALL_DATA_INSTANCE(CoroutineCancelled, (coroutine_t &), (coroutine_t))
-forall(T &)
-void mark_exception(CoroutineCancelled(T) *) {}
 forall(T &)
 void copy(CoroutineCancelled(T) * dst, CoroutineCancelled(T) * src) {
 …
 // This code should not be inlined. It is the error path on resume.
 forall(T & | is_coroutine(T))
+void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc ) {
+void __cfaehm_cancelled_coroutine(
+                T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) ) {
         verify( desc->cancellation );
         desc->state = Cancelled;
 …
         // TODO: Remove explitate vtable set once trac#186 is fixed.
         CoroutineCancelled(T) except;
         except.virtual_table = &get_exception_vtable(&except);
+        except.virtual_table = &_default_vtable;
         except.the_coroutine = &cor;
         except.the_exception = except;
+        throwResume except;
+        // Why does this need a cast?
+        throwResume (CoroutineCancelled(T) &)except;
         except->virtual_table->free( except );
 …
 // Part of the Public API
 // Not inline since only ever called once per coroutine
 forall(T & | is_coroutine(T))
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 void prime(T& cor) {
         $coroutine* this = get_coroutine(cor);
 …
 void __stack_clean  ( __stack_info_t * this ) {
-        size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
         void * storage = this->storage->limit;
         #if CFA_COROUTINE_USE_MMAP
+                size_t size = ((intptr_t)this->storage->base) - ((intptr_t)this->storage->limit) + sizeof(__stack_t);
                 storage = (void *)(((intptr_t)storage) - __page_size);
                 if(munmap(storage, size + __page_size) == -1) {

libcfa/src/concurrency/coroutine.hfa

-              rfeacef9
+              r5407cdc
 //-----------------------------------------------------------------------------
 // Exception thrown from resume when a coroutine stack is cancelled.
 FORALL_DATA_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
+EHM_FORALL_EXCEPTION(CoroutineCancelled, (coroutine_t &), (coroutine_t)) (
         coroutine_t * the_coroutine;
         exception_t * the_exception;
 …
 //-----------------------------------------------------------------------------
 // Public coroutine API
 forall(T & | is_coroutine(T))
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 void prime(T & cor);
 …
 forall(T & | is_coroutine(T))
+void __cfaehm_cancelled_coroutine( T & cor, $coroutine * desc );
+void __cfaehm_cancelled_coroutine(
+        T & cor, $coroutine * desc, EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)) );
 // Resume implementation inlined for performance
 forall(T & | is_coroutine(T))
+forall(T & | is_coroutine(T) | { EHM_DEFAULT_VTABLE(CoroutineCancelled, (T)); })
 static inline T & resume(T & cor) {
         // optimization : read TLS once and reuse it
 …
         $ctx_switch( src, dst );
         if ( unlikely(dst->cancellation) ) {
                 __cfaehm_cancelled_coroutine( cor, dst );
+                __cfaehm_cancelled_coroutine( cor, dst, _default_vtable );
+        }

libcfa/src/concurrency/future.hfa

-              rfeacef9
+              r5407cdc
                 // Fulfil the future, returns whether or not someone was unblocked
                 bool fulfil( future(T) & this, T result ) {
+                $thread * fulfil( future(T) & this, T result ) {
                         this.result = result;
                         return fulfil( (future_t&)this );
 …
                 bool fulfil( multi_future(T) & this, T result ) {
                         this.result = result;
                         return fulfil( (future_t&)this );
+                        return fulfil( (future_t&)this ) != 0p;
+                }

libcfa/src/concurrency/invoke.c

-              rfeacef9
+              r5407cdc
 extern void disable_interrupts() OPTIONAL_THREAD;
 extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+extern void enable_interrupts( _Bool poll );
 void __cfactx_invoke_coroutine(
 …
 ) {
         // Officially start the thread by enabling preemption
         enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts( true );
         // Call the main of the thread

libcfa/src/concurrency/invoke.h

-              rfeacef9
+              r5407cdc
                 struct $thread * prev;
                 volatile unsigned long long ts;
                 int preferred;
+                unsigned preferred;
         };
 …
                 } node;
+                struct processor * last_proc;
                 #if defined( __CFA_WITH_VERIFY__ )
                         void * canary;
 …
+                }
+                static inline $thread * volatile & ?`next ( $thread * this )  __attribute__((const)) {
+                        return this->seqable.next;
+                }
                 static inline $thread *& Back( $thread * this ) __attribute__((const)) {
                         return this->seqable.back;

libcfa/src/concurrency/io.cfa

-              rfeacef9
+              r5407cdc
         extern "C" {
                 #include <sys/syscall.h>
+                #include <sys/eventfd.h>
                 #include <linux/io_uring.h>
 …
         #include "kernel.hfa"
         #include "kernel/fwd.hfa"
+        #include "kernel_private.hfa"
         #include "io/types.hfa"
 …
         };
+        // returns true of acquired as leader or second leader
+        static inline bool try_lock( __leaderlock_t & this ) {
+                const uintptr_t thrd = 1z | (uintptr_t)active_thread();
+                bool block;
+                disable_interrupts();
+                for() {
+                        struct $thread * expected = this.value;
+                        if( 1p != expected && 0p != expected ) {
+                                /* paranoid */ verify( thrd != (uintptr_t)expected ); // We better not already be the next leader
+                                enable_interrupts( __cfaabi_dbg_ctx );
+                                return false;
+                        }
+                        struct $thread * desired;
+                        if( 0p == expected ) {
+                                // If the lock isn't locked acquire it, no need to block
+                                desired = 1p;
+                                block = false;
+                        }
+                        else {
+                                // If the lock is already locked try becomming the next leader
+                                desired = (struct $thread *)thrd;
+                                block = true;
+                        }
+                        if( __atomic_compare_exchange_n(&this.value, &expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ) break;
+                }
+                if( block ) {
+                        enable_interrupts( __cfaabi_dbg_ctx );
+                        park();
+                        disable_interrupts();
+                }
+                return true;
+        }
+        static inline bool next( __leaderlock_t & this ) {
+        static $io_context * __ioarbiter_allocate( $io_arbiter & this, __u32 idxs[], __u32 want );
+        static void __ioarbiter_submit( $io_context * , __u32 idxs[], __u32 have, bool lazy );
+        static void __ioarbiter_flush ( $io_context & );
+        static inline void __ioarbiter_notify( $io_context & ctx );
+//=============================================================================================
+// I/O Polling
+//=============================================================================================
+        static inline unsigned __flush( struct $io_context & );
+        static inline __u32 __release_sqes( struct $io_context & );
+        extern void __kernel_unpark( $thread * thrd );
+        bool __cfa_io_drain( processor * proc ) {
                 /* paranoid */ verify( ! __preemption_enabled() );
+                struct $thread * nextt;
+                for() {
+                        struct $thread * expected = this.value;
+                        /* paranoid */ verify( (1 & (uintptr_t)expected) == 1 ); // The lock better be locked
+                        struct $thread * desired;
+                        if( 1p == expected ) {
+                                // No next leader, just unlock
+                                desired = 0p;
+                                nextt   = 0p;
+                        }
+                        else {
+                                // There is a next leader, remove but keep locked
+                                desired = 1p;
+                                nextt   = (struct $thread *)(~1z & (uintptr_t)expected);
+                        }
+                        if( __atomic_compare_exchange_n(&this.value, &expected, desired, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST) ) break;
+                }
+                if(nextt) {
+                        unpark( nextt );
+                        enable_interrupts( __cfaabi_dbg_ctx );
+                        return true;
+                }
+                enable_interrupts( __cfaabi_dbg_ctx );
+                return false;
+        }
+//=============================================================================================
+// I/O Syscall
+//=============================================================================================
+        static int __io_uring_enter( struct __io_data & ring, unsigned to_submit, bool get ) {
+                bool need_sys_to_submit = false;
+                bool need_sys_to_complete = false;
+                unsigned flags = 0;
+                TO_SUBMIT:
+                if( to_submit > 0 ) {
+                        if( !(ring.ring_flags & IORING_SETUP_SQPOLL) ) {
+                                need_sys_to_submit = true;
+                                break TO_SUBMIT;
+                        }
+                        if( (*ring.submit_q.flags) & IORING_SQ_NEED_WAKEUP ) {
+                                need_sys_to_submit = true;
+                                flags |= IORING_ENTER_SQ_WAKEUP;
+                        }
+                }
+                if( get && !(ring.ring_flags & IORING_SETUP_SQPOLL) ) {
+                        flags |= IORING_ENTER_GETEVENTS;
+                        if( (ring.ring_flags & IORING_SETUP_IOPOLL) ) {
+                                need_sys_to_complete = true;
+                        }
+                }
+                int ret = 0;
+                if( need_sys_to_submit || need_sys_to_complete ) {
+                        __cfadbg_print_safe(io_core, "Kernel I/O : IO_URING enter %d %u %u\n", ring.fd, to_submit, flags);
+                        ret = syscall( __NR_io_uring_enter, ring.fd, to_submit, 0, flags, (sigset_t *)0p, _NSIG / 8);
+                        __cfadbg_print_safe(io_core, "Kernel I/O : IO_URING %d returned %d\n", ring.fd, ret);
+                        if( ret < 0 ) {
+                                switch((int)errno) {
+                                case EAGAIN:
+                                case EINTR:
+                                case EBUSY:
+                                        ret = -1;
+                                        break;
+                                default:
+                                        abort( "KERNEL ERROR: IO_URING SYSCALL - (%d) %s\n", (int)errno, strerror(errno) );
+                                }
+                        }
+                }
+                // Memory barrier
+                __atomic_thread_fence( __ATOMIC_SEQ_CST );
+                return ret;
+        }
+//=============================================================================================
+// I/O Polling
+//=============================================================================================
+        static unsigned __collect_submitions( struct __io_data & ring );
+        static __u32 __release_consumed_submission( struct __io_data & ring );
+        static inline void __clean( volatile struct io_uring_sqe * sqe );
+        // Process a single completion message from the io_uring
+        // This is NOT thread-safe
+        static inline void process( volatile struct io_uring_cqe & cqe ) {
+                struct io_future_t * future = (struct io_future_t *)(uintptr_t)cqe.user_data;
+                __cfadbg_print_safe( io, "Kernel I/O : Syscall completed : cqe %p, result %d for %p\n", &cqe, cqe.res, future );
+                fulfil( *future, cqe.res );
+        }
+        static [int, bool] __drain_io( & struct __io_data ring ) {
+                /* paranoid */ verify( ! __preemption_enabled() );
+                unsigned to_submit = 0;
+                if( ring.poller_submits ) {
+                        // If the poller thread also submits, then we need to aggregate the submissions which are ready
+                        to_submit = __collect_submitions( ring );
+                }
+                int ret = __io_uring_enter(ring, to_submit, true);
+                if( ret < 0 ) {
+                        return [0, true];
+                }
+                // update statistics
+                if (to_submit > 0) {
+                        __STATS__( true,
+                                if( to_submit > 0 ) {
+                                        io.submit_q.submit_avg.rdy += to_submit;
+                                        io.submit_q.submit_avg.csm += ret;
+                                        io.submit_q.submit_avg.cnt += 1;
+                                }
+                        )
+                }
+                __atomic_thread_fence( __ATOMIC_SEQ_CST );
+                // Release the consumed SQEs
+                __release_consumed_submission( ring );
+                /* paranoid */ verify( ready_schedule_islocked() );
+                /* paranoid */ verify( proc );
+                /* paranoid */ verify( proc->io.ctx );
                 // Drain the queue
+                unsigned head = *ring.completion_q.head;
+                unsigned tail = *ring.completion_q.tail;
+                const __u32 mask = *ring.completion_q.mask;
+                // Nothing was new return 0
+                if (head == tail) {
+                        return [0, to_submit > 0];
+                }
+                $io_context * ctx = proc->io.ctx;
+                unsigned head = *ctx->cq.head;
+                unsigned tail = *ctx->cq.tail;
+                const __u32 mask = *ctx->cq.mask;
                 __u32 count = tail - head;
+                /* paranoid */ verify( count != 0 );
+                __STATS__( false, io.calls.drain++; io.calls.completed += count; )
+                if(count == 0) return false;
                 for(i; count) {
                         unsigned idx = (head + i) & mask;
                         volatile struct io_uring_cqe & cqe = ring.completion_q.cqes[idx];
+                        volatile struct io_uring_cqe & cqe = ctx->cq.cqes[idx];
                         /* paranoid */ verify(&cqe);
+                        process( cqe );
+                }
+                        struct io_future_t * future = (struct io_future_t *)(uintptr_t)cqe.user_data;
+                        __cfadbg_print_safe( io, "Kernel I/O : Syscall completed : cqe %p, result %d for %p\n", &cqe, cqe.res, future );
+                        __kernel_unpark( fulfil( *future, cqe.res, false ) );
+                }
+                __cfadbg_print_safe(io, "Kernel I/O : %u completed\n", count);
                 // Mark to the kernel that the cqe has been seen
                 // Ensure that the kernel only sees the new value of the head index after the CQEs have been read.
+                __atomic_fetch_add( ring.completion_q.head, count, __ATOMIC_SEQ_CST );
+                return [count, count > 0 || to_submit > 0];
+        }
+        void main( $io_ctx_thread & this ) {
+                __ioctx_register( this );
+                __cfadbg_print_safe(io_core, "Kernel I/O : IO poller %d (%p) ready\n", this.ring->fd, &this);
+                const int reset_cnt = 5;
+                int reset = reset_cnt;
+                // Then loop until we need to start
+                LOOP:
+                while(!__atomic_load_n(&this.done, __ATOMIC_SEQ_CST)) {
+                        // Drain the io
+                        int count;
+                        bool again;
+                        disable_interrupts();
+                                [count, again] = __drain_io( *this.ring );
+                                if(!again) reset--;
+                __atomic_store_n( ctx->cq.head, head + count, __ATOMIC_SEQ_CST );
+                /* paranoid */ verify( ready_schedule_islocked() );
+                /* paranoid */ verify( ! __preemption_enabled() );
+                return true;
+        }
+        void __cfa_io_flush( processor * proc ) {
+                /* paranoid */ verify( ! __preemption_enabled() );
+                /* paranoid */ verify( proc );
+                /* paranoid */ verify( proc->io.ctx );
+                $io_context & ctx = *proc->io.ctx;
+                __ioarbiter_flush( ctx );
+                __STATS__( true, io.calls.flush++; )
+                int ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, 0, 0, (sigset_t *)0p, _NSIG / 8);
+                if( ret < 0 ) {
+                        switch((int)errno) {
+                        case EAGAIN:
+                        case EINTR:
+                        case EBUSY:
                                 // Update statistics
+                                __STATS__( true,
+                                        io.complete_q.completed_avg.val += count;
+                                        io.complete_q.completed_avg.cnt += 1;
+                                )
+                        enable_interrupts( __cfaabi_dbg_ctx );
+                        // If we got something, just yield and check again
+                        if(reset > 1) {
+                                yield();
+                                continue LOOP;
+                                __STATS__( false, io.calls.errors.busy ++; )
+                                return;
+                        default:
+                                abort( "KERNEL ERROR: IO_URING SYSCALL - (%d) %s\n", (int)errno, strerror(errno) );
+                        }
+                        // We alread failed to find completed entries a few time.
+                        if(reset == 1) {
+                                // Rearm the context so it can block
+                                // but don't block right away
+                                // we need to retry one last time in case
+                                // something completed *just now*
+                                __ioctx_prepare_block( this );
+                                continue LOOP;
+                        }
+                                __STATS__( false,
+                                        io.complete_q.blocks += 1;
+                                )
+                                __cfadbg_print_safe(io_core, "Kernel I/O : Parking io poller %d (%p)\n", this.ring->fd, &this);
+                                // block this thread
+                                wait( this.sem );
+                        // restore counter
+                        reset = reset_cnt;
+                }
+                __cfadbg_print_safe(io_core, "Kernel I/O : Fast poller %d (%p) stopping\n", this.ring->fd, &this);
+                __ioctx_unregister( this );
+                }
+                __cfadbg_print_safe(io, "Kernel I/O : %u submitted to io_uring %d\n", ret, ctx.fd);
+                __STATS__( true, io.calls.submitted += ret; )
+                /* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
+                /* paranoid */ verify( ctx.sq.to_submit >= ret );
+                ctx.sq.to_submit -= ret;
+                /* paranoid */ verify( ctx.sq.to_submit <= *ctx.sq.num );
+                // Release the consumed SQEs
+                __release_sqes( ctx );
+                /* paranoid */ verify( ! __preemption_enabled() );
+                ctx.proc->io.pending = false;
+        }
 …
 //         head and tail must be fully filled and shouldn't ever be touched again.
 //
+        //=============================================================================================
+        // Allocation
+        // for user's convenience fill the sqes from the indexes
+        static inline void __fill(struct io_uring_sqe * out_sqes[], __u32 want, __u32 idxs[], struct $io_context * ctx)  {
+                struct io_uring_sqe * sqes = ctx->sq.sqes;
+                for(i; want) {
+                        __cfadbg_print_safe(io, "Kernel I/O : filling loop\n");
+                        out_sqes[i] = &sqes[idxs[i]];
+                }
+        }
+        // Try to directly allocate from the a given context
+        // Not thread-safe
+        static inline bool __alloc(struct $io_context * ctx, __u32 idxs[], __u32 want) {
+                __sub_ring_t & sq = ctx->sq;
+                const __u32 mask  = *sq.mask;
+                __u32 fhead = sq.free_ring.head;    // get the current head of the queue
+                __u32 ftail = sq.free_ring.tail;    // get the current tail of the queue
+                // If we don't have enough sqes, fail
+                if((ftail - fhead) < want) { return false; }
+                // copy all the indexes we want from the available list
+                for(i; want) {
+                        __cfadbg_print_safe(io, "Kernel I/O : allocating loop\n");
+                        idxs[i] = sq.free_ring.array[(fhead + i) & mask];
+                }
+                // Advance the head to mark the indexes as consumed
+                __atomic_store_n(&sq.free_ring.head, fhead + want, __ATOMIC_RELEASE);
+                // return success
+                return true;
+        }
         // Allocate an submit queue entry.
 …
         // for convenience, return both the index and the pointer to the sqe
         // sqe == &sqes[idx]
+        [* volatile struct io_uring_sqe, __u32] __submit_alloc( struct __io_data & ring, __u64 data ) {
+                /* paranoid */ verify( data != 0 );
+                // Prepare the data we need
+                __attribute((unused)) int len   = 0;
+                __attribute((unused)) int block = 0;
+                __u32 cnt = *ring.submit_q.num;
+                __u32 mask = *ring.submit_q.mask;
+                __u32 off = thread_rand();
+                // Loop around looking for an available spot
+                for() {
+                        // Look through the list starting at some offset
+                        for(i; cnt) {
+                                __u64 expected = 3;
+                                __u32 idx = (i + off) & mask; // Get an index from a random
+                                volatile struct io_uring_sqe * sqe = &ring.submit_q.sqes[idx];
+                                volatile __u64 * udata = &sqe->user_data;
+                                // Allocate the entry by CASing the user_data field from 0 to the future address
+                                if( *udata == expected &&
+                                        __atomic_compare_exchange_n( udata, &expected, data, true, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED ) )
+                                {
+                                        // update statistics
+                                        __STATS__( false,
+                                                io.submit_q.alloc_avg.val   += len;
+                                                io.submit_q.alloc_avg.block += block;
+                                                io.submit_q.alloc_avg.cnt   += 1;
+                                        )
+                                        // debug log
+                                        __cfadbg_print_safe( io, "Kernel I/O : allocated [%p, %u] for %p (%p)\n", sqe, idx, active_thread(), (void*)data );
+                                        // Success return the data
+                                        return [sqe, idx];
+                                }
+                                verify(expected != data);
+                                // This one was used
+                                len ++;
+                        }
+                        block++;
+                        yield();
+                }
+        }
+        static inline __u32 __submit_to_ready_array( struct __io_data & ring, __u32 idx, const __u32 mask ) {
+                /* paranoid */ verify( idx <= mask   );
+                /* paranoid */ verify( idx != -1ul32 );
+                // We need to find a spot in the ready array
+                __attribute((unused)) int len   = 0;
+                __attribute((unused)) int block = 0;
+                __u32 ready_mask = ring.submit_q.ready_cnt - 1;
+                __u32 off = thread_rand();
+                __u32 picked;
+                LOOKING: for() {
+                        for(i; ring.submit_q.ready_cnt) {
+                                picked = (i + off) & ready_mask;
+                                __u32 expected = -1ul32;
+                                if( __atomic_compare_exchange_n( &ring.submit_q.ready[picked], &expected, idx, true, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED ) ) {
+                                        break LOOKING;
+                                }
+                                verify(expected != idx);
+                                len ++;
+                        }
+                        block++;
+                        __u32 released = __release_consumed_submission( ring );
+                        if( released == 0 ) {
+                                yield();
+                        }
+                }
+                // update statistics
+                __STATS__( false,
+                        io.submit_q.look_avg.val   += len;
+                        io.submit_q.look_avg.block += block;
+                        io.submit_q.look_avg.cnt   += 1;
+                )
+                return picked;
+        }
+        void __submit( struct io_context * ctx, __u32 idx ) __attribute__((nonnull (1))) {
+                __io_data & ring = *ctx->thrd.ring;
+        struct $io_context * cfa_io_allocate(struct io_uring_sqe * sqes[], __u32 idxs[], __u32 want) {
+                __cfadbg_print_safe(io, "Kernel I/O : attempting to allocate %u\n", want);
+                disable_interrupts();
+                processor * proc = __cfaabi_tls.this_processor;
+                $io_context * ctx = proc->io.ctx;
+                /* paranoid */ verify( __cfaabi_tls.this_processor );
+                /* paranoid */ verify( ctx );
+                __cfadbg_print_safe(io, "Kernel I/O : attempting to fast allocation\n");
+                // We can proceed to the fast path
+                if( __alloc(ctx, idxs, want) ) {
+                        // Allocation was successful
+                        __STATS__( true, io.alloc.fast += 1; )
+                        enable_interrupts();
+                        __cfadbg_print_safe(io, "Kernel I/O : fast allocation successful from ring %d\n", ctx->fd);
+                        __fill( sqes, want, idxs, ctx );
+                        return ctx;
+                }
+                // The fast path failed, fallback
+                __STATS__( true, io.alloc.fail += 1; )
+                // Fast path failed, fallback on arbitration
+                __STATS__( true, io.alloc.slow += 1; )
+                enable_interrupts();
+                $io_arbiter * ioarb = proc->cltr->io.arbiter;
+                /* paranoid */ verify( ioarb );
+                __cfadbg_print_safe(io, "Kernel I/O : falling back on arbiter for allocation\n");
+                struct $io_context * ret = __ioarbiter_allocate(*ioarb, idxs, want);
+                __cfadbg_print_safe(io, "Kernel I/O : slow allocation completed from ring %d\n", ret->fd);
+                __fill( sqes, want, idxs,ret );
+                return ret;
+        }
+        //=============================================================================================
+        // submission
+        static inline void __submit( struct $io_context * ctx, __u32 idxs[], __u32 have, bool lazy) {
+                // We can proceed to the fast path
+                // Get the right objects
+                __sub_ring_t & sq = ctx->sq;
+                const __u32 mask  = *sq.mask;
+                __u32 tail = *sq.kring.tail;
+                // Add the sqes to the array
+                for( i; have ) {
+                        __cfadbg_print_safe(io, "Kernel I/O : __submit loop\n");
+                        sq.kring.array[ (tail + i) & mask ] = idxs[i];
+                }
+                // Make the sqes visible to the submitter
+                __atomic_store_n(sq.kring.tail, tail + have, __ATOMIC_RELEASE);
+                sq.to_submit++;
+                ctx->proc->io.pending = true;
+                ctx->proc->io.dirty   = true;
+                if(sq.to_submit > 30 || !lazy) {
+                        __cfa_io_flush( ctx->proc );
+                }
+        }
+        void cfa_io_submit( struct $io_context * inctx, __u32 idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1))) {
+                __cfadbg_print_safe(io, "Kernel I/O : attempting to submit %u (%s)\n", have, lazy ? "lazy" : "eager");
+                disable_interrupts();
+                processor * proc = __cfaabi_tls.this_processor;
+                $io_context * ctx = proc->io.ctx;
+                /* paranoid */ verify( __cfaabi_tls.this_processor );
+                /* paranoid */ verify( ctx );
+                // Can we proceed to the fast path
+                if( ctx == inctx )              // We have the right instance?
+                {
+                        __attribute__((unused)) volatile struct io_uring_sqe * sqe = &ring.submit_q.sqes[idx];
+                        __cfadbg_print_safe( io,
+                                "Kernel I/O : submitting %u (%p) for %p\n"
+                                "    data: %p\n"
+                                "    opcode: %s\n"
+                                "    fd: %d\n"
+                                "    flags: %d\n"
+                                "    prio: %d\n"
+                                "    off: %p\n"
+                                "    addr: %p\n"
+                                "    len: %d\n"
+                                "    other flags: %d\n"
+                                "    splice fd: %d\n"
+                                "    pad[0]: %llu\n"
+                                "    pad[1]: %llu\n"
+                                "    pad[2]: %llu\n",
+                                idx, sqe,
+                                active_thread(),
+                                (void*)sqe->user_data,
+                                opcodes[sqe->opcode],
+                                sqe->fd,
+                                sqe->flags,
+                                sqe->ioprio,
+                                (void*)sqe->off,
+                                (void*)sqe->addr,
+                                sqe->len,
+                                sqe->accept_flags,
+                                sqe->splice_fd_in,
+                                sqe->__pad2[0],
+                                sqe->__pad2[1],
+                                sqe->__pad2[2]
+                        );
+                }
+                // Get now the data we definetely need
+                volatile __u32 * const tail = ring.submit_q.tail;
+                const __u32 mask  = *ring.submit_q.mask;
+                // There are 2 submission schemes, check which one we are using
+                if( ring.poller_submits ) {
+                        // If the poller thread submits, then we just need to add this to the ready array
+                        __submit_to_ready_array( ring, idx, mask );
+                        post( ctx->thrd.sem );
+                        __cfadbg_print_safe( io, "Kernel I/O : Added %u to ready for %p\n", idx, active_thread() );
+                }
+                else if( ring.eager_submits ) {
+                        __attribute__((unused)) __u32 picked = __submit_to_ready_array( ring, idx, mask );
+                        #if defined(LEADER_LOCK)
+                                if( !try_lock(ring.submit_q.submit_lock) ) {
+                                        __STATS__( false,
+                                                io.submit_q.helped += 1;
+                                        )
+                                        return;
+                                }
+                                /* paranoid */ verify( ! __preemption_enabled() );
+                                __STATS__( true,
+                                        io.submit_q.leader += 1;
+                                )
+                        #else
+                                for() {
+                                        yield();
+                                        if( try_lock(ring.submit_q.submit_lock __cfaabi_dbg_ctx2) ) {
+                                                __STATS__( false,
+                                                        io.submit_q.leader += 1;
+                                                )
+                                                break;
+                                        }
+                                        // If some one else collected our index, we are done
+                                        #warning ABA problem
+                                        if( ring.submit_q.ready[picked] != idx ) {
+                                                __STATS__( false,
+                                                        io.submit_q.helped += 1;
+                                                )
+                                                return;
+                                        }
+                                        __STATS__( false,
+                                                io.submit_q.busy += 1;
+                                        )
+                                }
+                        #endif
+                        // We got the lock
+                        // Collect the submissions
+                        unsigned to_submit = __collect_submitions( ring );
+                        // Actually submit
+                        int ret = __io_uring_enter( ring, to_submit, false );
+                        #if defined(LEADER_LOCK)
+                                /* paranoid */ verify( ! __preemption_enabled() );
+                                next(ring.submit_q.submit_lock);
+                        #else
+                                unlock(ring.submit_q.submit_lock);
+                        #endif
+                        if( ret < 0 ) {
+                                return;
+                        }
+                        // Release the consumed SQEs
+                        __release_consumed_submission( ring );
+                        // update statistics
+                        __STATS__( false,
+                                io.submit_q.submit_avg.rdy += to_submit;
+                                io.submit_q.submit_avg.csm += ret;
+                                io.submit_q.submit_avg.cnt += 1;
+                        )
+                        __cfadbg_print_safe( io, "Kernel I/O : submitted %u (among %u) for %p\n", idx, ret, active_thread() );
+                }
+                else
+                {
+                        // get mutual exclusion
+                        #if defined(LEADER_LOCK)
+                                while(!try_lock(ring.submit_q.submit_lock));
+                        #else
+                                lock(ring.submit_q.submit_lock __cfaabi_dbg_ctx2);
+                        #endif
+                        /* paranoid */ verifyf( ring.submit_q.sqes[ idx ].user_data != 3ul64,
+                        /* paranoid */  "index %u already reclaimed\n"
+                        /* paranoid */  "head %u, prev %u, tail %u\n"
+                        /* paranoid */  "[-0: %u,-1: %u,-2: %u,-3: %u]\n",
+                        /* paranoid */  idx,
+                        /* paranoid */  *ring.submit_q.head, ring.submit_q.prev_head, *tail
+                        /* paranoid */  ,ring.submit_q.array[ ((*ring.submit_q.head) - 0) & (*ring.submit_q.mask) ]
+                        /* paranoid */  ,ring.submit_q.array[ ((*ring.submit_q.head) - 1) & (*ring.submit_q.mask) ]
+                        /* paranoid */  ,ring.submit_q.array[ ((*ring.submit_q.head) - 2) & (*ring.submit_q.mask) ]
+                        /* paranoid */  ,ring.submit_q.array[ ((*ring.submit_q.head) - 3) & (*ring.submit_q.mask) ]
+                        /* paranoid */ );
+                        // Append to the list of ready entries
+                        /* paranoid */ verify( idx <= mask );
+                        ring.submit_q.array[ (*tail) & mask ] = idx;
+                        __atomic_fetch_add(tail, 1ul32, __ATOMIC_SEQ_CST);
+                        // Submit however, many entries need to be submitted
+                        int ret = __io_uring_enter( ring, 1, false );
+                        if( ret < 0 ) {
+                                switch((int)errno) {
+                                default:
+                                        abort( "KERNEL ERROR: IO_URING SUBMIT - %s\n", strerror(errno) );
+                                }
+                        }
+                        /* paranoid */ verify(ret == 1);
+                        // update statistics
+                        __STATS__( false,
+                                io.submit_q.submit_avg.csm += 1;
+                                io.submit_q.submit_avg.cnt += 1;
+                        )
+                        {
+                                __attribute__((unused)) volatile __u32 * const head = ring.submit_q.head;
+                                __attribute__((unused)) __u32 last_idx = ring.submit_q.array[ ((*head) - 1) & mask ];
+                                __attribute__((unused)) volatile struct io_uring_sqe * sqe = &ring.submit_q.sqes[last_idx];
+                                __cfadbg_print_safe( io,
+                                        "Kernel I/O : last submitted is %u (%p)\n"
+                                        "    data: %p\n"
+                                        "    opcode: %s\n"
+                                        "    fd: %d\n"
+                                        "    flags: %d\n"
+                                        "    prio: %d\n"
+                                        "    off: %p\n"
+                                        "    addr: %p\n"
+                                        "    len: %d\n"
+                                        "    other flags: %d\n"
+                                        "    splice fd: %d\n"
+                                        "    pad[0]: %llu\n"
+                                        "    pad[1]: %llu\n"
+                                        "    pad[2]: %llu\n",
+                                        last_idx, sqe,
+                                        (void*)sqe->user_data,
+                                        opcodes[sqe->opcode],
+                                        sqe->fd,
+                                        sqe->flags,
+                                        sqe->ioprio,
+                                        (void*)sqe->off,
+                                        (void*)sqe->addr,
+                                        sqe->len,
+                                        sqe->accept_flags,
+                                        sqe->splice_fd_in,
+                                        sqe->__pad2[0],
+                                        sqe->__pad2[1],
+                                        sqe->__pad2[2]
+                                );
+                        }
+                        __atomic_thread_fence( __ATOMIC_SEQ_CST );
+                        // Release the consumed SQEs
+                        __release_consumed_submission( ring );
+                        // ring.submit_q.sqes[idx].user_data = 3ul64;
+                        #if defined(LEADER_LOCK)
+                                next(ring.submit_q.submit_lock);
+                        #else
+                                unlock(ring.submit_q.submit_lock);
+                        #endif
+                        __cfadbg_print_safe( io, "Kernel I/O : submitted %u for %p\n", idx, active_thread() );
+                }
+        }
+        // #define PARTIAL_SUBMIT 32
+        // go through the list of submissions in the ready array and moved them into
+        // the ring's submit queue
+        static unsigned __collect_submitions( struct __io_data & ring ) {
+                /* paranoid */ verify( ring.submit_q.ready != 0p );
+                /* paranoid */ verify( ring.submit_q.ready_cnt > 0 );
+                unsigned to_submit = 0;
+                __u32 tail = *ring.submit_q.tail;
+                const __u32 mask = *ring.submit_q.mask;
+                #if defined(PARTIAL_SUBMIT)
+                        #if defined(LEADER_LOCK)
+                                #error PARTIAL_SUBMIT and LEADER_LOCK cannot co-exist
+                        #endif
+                        const __u32 cnt = ring.submit_q.ready_cnt > PARTIAL_SUBMIT ? PARTIAL_SUBMIT : ring.submit_q.ready_cnt;
+                        const __u32 offset = ring.submit_q.prev_ready;
+                        ring.submit_q.prev_ready += cnt;
+                #else
+                        const __u32 cnt = ring.submit_q.ready_cnt;
+                        const __u32 offset = 0;
+                #endif
+                // Go through the list of ready submissions
+                for( c; cnt ) {
+                        __u32 i = (offset + c) % ring.submit_q.ready_cnt;
+                        // replace any submission with the sentinel, to consume it.
+                        __u32 idx = __atomic_exchange_n( &ring.submit_q.ready[i], -1ul32, __ATOMIC_RELAXED);
+                        // If it was already the sentinel, then we are done
+                        if( idx == -1ul32 ) continue;
+                        // If we got a real submission, append it to the list
+                        ring.submit_q.array[ (tail + to_submit) & mask ] = idx & mask;
+                        to_submit++;
+                }
+                // Increment the tail based on how many we are ready to submit
+                __atomic_fetch_add(ring.submit_q.tail, to_submit, __ATOMIC_SEQ_CST);
+                return to_submit;
+        }
+                        __submit(ctx, idxs, have, lazy);
+                        // Mark the instance as no longer in-use, re-enable interrupts and return
+                        __STATS__( true, io.submit.fast += 1; )
+                        enable_interrupts();
+                        __cfadbg_print_safe(io, "Kernel I/O : submitted on fast path\n");
+                        return;
+                }
+                // Fast path failed, fallback on arbitration
+                __STATS__( true, io.submit.slow += 1; )
+                enable_interrupts();
+                __cfadbg_print_safe(io, "Kernel I/O : falling back on arbiter for submission\n");
+                __ioarbiter_submit(inctx, idxs, have, lazy);
+        }
+        //=============================================================================================
+        // Flushing
         // Go through the ring's submit queue and release everything that has already been consumed
         // by io_uring
+        static __u32 __release_consumed_submission( struct __io_data & ring ) {
+                const __u32 smask = *ring.submit_q.mask;
+                // We need to get the lock to copy the old head and new head
+                if( !try_lock(ring.submit_q.release_lock __cfaabi_dbg_ctx2) ) return 0;
+        // This cannot be done by multiple threads
+        static __u32 __release_sqes( struct $io_context & ctx ) {
+                const __u32 mask = *ctx.sq.mask;
                 __attribute__((unused))
                 __u32 ctail = *ring.submit_q.tail;        // get the current tail of the queue
                 __u32 chead = *ring.submit_q.head;              // get the current head of the queue
                 __u32 phead = ring.submit_q.prev_head;  // get the head the last time we were here
+                ring.submit_q.prev_head = chead;                // note up to were we processed
                 unlock(ring.submit_q.release_lock);
+                __u32 ctail = *ctx.sq.kring.tail;    // get the current tail of the queue
+                __u32 chead = *ctx.sq.kring.head;        // get the current head of the queue
+                __u32 phead = ctx.sq.kring.released; // get the head the last time we were here
+                __u32 ftail = ctx.sq.free_ring.tail;  // get the current tail of the queue
                 // the 3 fields are organized like this diagram
 …
                 __u32 count = chead - phead;
+                if(count == 0) {
+                        return 0;
+                }
                 // We acquired an previous-head/current-head range
                 // go through the range and release the sqes
                 for( i; count ) {
+                        __u32 idx = ring.submit_q.array[ (phead + i) & smask ];
+                        /* paranoid */ verify( 0 != ring.submit_q.sqes[ idx ].user_data );
+                        __clean( &ring.submit_q.sqes[ idx ] );
+                }
+                        __cfadbg_print_safe(io, "Kernel I/O : release loop\n");
+                        __u32 idx = ctx.sq.kring.array[ (phead + i) & mask ];
+                        ctx.sq.free_ring.array[ (ftail + i) & mask ] = idx;
+                }
+                ctx.sq.kring.released = chead;          // note up to were we processed
+                __atomic_store_n(&ctx.sq.free_ring.tail, ftail + count, __ATOMIC_SEQ_CST);
+                __ioarbiter_notify(ctx);
                 return count;
+        }
+        void __sqe_clean( volatile struct io_uring_sqe * sqe ) {
+                __clean( sqe );
+        }
+        static inline void __clean( volatile struct io_uring_sqe * sqe ) {
+                // If we are in debug mode, thrash the fields to make sure we catch reclamation errors
+                __cfaabi_dbg_debug_do(
+                        memset(sqe, 0xde, sizeof(*sqe));
+                        sqe->opcode = (sizeof(opcodes) / sizeof(const char *)) - 1;
+                );
+                // Mark the entry as unused
+                __atomic_store_n(&sqe->user_data, 3ul64, __ATOMIC_SEQ_CST);
+//=============================================================================================
+// I/O Arbiter
+//=============================================================================================
+        static inline void block(__outstanding_io_queue & queue, __outstanding_io & item) {
+                // Lock the list, it's not thread safe
+                lock( queue.lock __cfaabi_dbg_ctx2 );
+                {
+                        // Add our request to the list
+                        add( queue.queue, item );
+                        // Mark as pending
+                        __atomic_store_n( &queue.empty, false, __ATOMIC_SEQ_CST );
+                }
+                unlock( queue.lock );
+                wait( item.sem );
+        }
+        static inline bool empty(__outstanding_io_queue & queue ) {
+                return __atomic_load_n( &queue.empty, __ATOMIC_SEQ_CST);
+        }
+        static $io_context * __ioarbiter_allocate( $io_arbiter & this, __u32 idxs[], __u32 want ) {
+                __cfadbg_print_safe(io, "Kernel I/O : arbiter allocating\n");
+                __STATS__( false, io.alloc.block += 1; )
+                // No one has any resources left, wait for something to finish
+                // We need to add ourself to a list of pending allocs and wait for an answer
+                __pending_alloc pa;
+                pa.idxs = idxs;
+                pa.want = want;
+                block(this.pending, (__outstanding_io&)pa);
+                return pa.ctx;
+        }
+        static void __ioarbiter_notify( $io_arbiter & this, $io_context * ctx ) {
+                /* paranoid */ verify( !empty(this.pending.queue) );
+                lock( this.pending.lock __cfaabi_dbg_ctx2 );
+                {
+                        while( !empty(this.pending.queue) ) {
+                                __cfadbg_print_safe(io, "Kernel I/O : notifying\n");
+                                __u32 have = ctx->sq.free_ring.tail - ctx->sq.free_ring.head;
+                                __pending_alloc & pa = (__pending_alloc&)head( this.pending.queue );
+                                if( have > pa.want ) goto DONE;
+                                drop( this.pending.queue );
+                                /* paranoid */__attribute__((unused)) bool ret =
+                                __alloc(ctx, pa.idxs, pa.want);
+                                /* paranoid */ verify( ret );
+                                pa.ctx = ctx;
+                                post( pa.sem );
+                        }
+                        this.pending.empty = true;
+                        DONE:;
+                }
+                unlock( this.pending.lock );
+        }
+        static void __ioarbiter_notify( $io_context & ctx ) {
+                if(!empty( ctx.arbiter->pending )) {
+                        __ioarbiter_notify( *ctx.arbiter, &ctx );
+                }
+        }
+        // Simply append to the pending
+        static void __ioarbiter_submit( $io_context * ctx, __u32 idxs[], __u32 have, bool lazy ) {
+                __cfadbg_print_safe(io, "Kernel I/O : submitting %u from the arbiter to context %u\n", have, ctx->fd);
+                __cfadbg_print_safe(io, "Kernel I/O : waiting to submit %u\n", have);
+                __external_io ei;
+                ei.idxs = idxs;
+                ei.have = have;
+                ei.lazy = lazy;
+                block(ctx->ext_sq, (__outstanding_io&)ei);
+                __cfadbg_print_safe(io, "Kernel I/O : %u submitted from arbiter\n", have);
+        }
+        static void __ioarbiter_flush( $io_context & ctx ) {
+                if(!empty( ctx.ext_sq )) {
+                        __STATS__( false, io.flush.external += 1; )
+                        __cfadbg_print_safe(io, "Kernel I/O : arbiter flushing\n");
+                        lock( ctx.ext_sq.lock __cfaabi_dbg_ctx2 );
+                        {
+                                while( !empty(ctx.ext_sq.queue) ) {
+                                        __external_io & ei = (__external_io&)drop( ctx.ext_sq.queue );
+                                        __submit(&ctx, ei.idxs, ei.have, ei.lazy);
+                                        post( ei.sem );
+                                }
+                                ctx.ext_sq.empty = true;
+                        }
+                        unlock(ctx.ext_sq.lock );
+                }
+        }
 #endif

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

-              rfeacef9
+              r5407cdc
                         | IOSQE_IO_DRAIN
                 #endif
+                #if defined(CFA_HAVE_IOSQE_IO_LINK)
+                        | IOSQE_IO_LINK
+                #endif
+                #if defined(CFA_HAVE_IOSQE_IO_HARDLINK)
+                        | IOSQE_IO_HARDLINK
+                #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
+                #if defined(CFA_HAVE_IOSQE_BUFFER_SELECTED)
+                        | IOSQE_BUFFER_SELECTED
                 #endif
+        ;
 …
+        ;
+        extern [* volatile struct io_uring_sqe, __u32] __submit_alloc( struct __io_data & ring, __u64 data );
+        extern void __submit( struct io_context * ctx, __u32 idx ) __attribute__((nonnull (1)));
+        static inline io_context * __get_io_context( void ) {
+                cluster * cltr = active_cluster();
+                /* paranoid */ verifyf( cltr, "No active cluster for io operation\\n");
+                assertf( cltr->io.cnt > 0, "Cluster %p has no default io contexts and no context was specified\\n", cltr );
+                /* paranoid */ verifyf( cltr->io.ctxs, "default io contexts for cluster %p are missing\\n", cltr);
+                return &cltr->io.ctxs[ thread_rand() % cltr->io.cnt ];
+        }
+        extern struct $io_context * cfa_io_allocate(struct io_uring_sqe * out_sqes[], __u32 out_idxs[], __u32 want)  __attribute__((nonnull (1,2)));
+        extern void cfa_io_submit( struct $io_context * in_ctx, __u32 in_idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1,2)));
 #endif
 …
 extern "C" {
         #include <sys/types.h>
+        #include <asm/types.h>
         #include <sys/socket.h>
         #include <sys/syscall.h>
 …
         extern int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
         extern ssize_t splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags);
+        extern ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags);
         extern ssize_t tee(int fd_in, int fd_out, size_t len, unsigned int flags);
+}
 …
                 return ', '.join(args_a)
 AsyncTemplate = """inline void async_{name}(io_future_t & future, {params}, int submit_flags, io_cancellation * cancellation, io_context * context) {{
+AsyncTemplate = """inline void async_{name}(io_future_t & future, {params}, __u64 submit_flags) {{
         #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_{op})
                 ssize_t res = {name}({args});
 …
                 }}
         #else
-                // we don't support LINK yet
-                if( 0 != (submit_flags & LINK_FLAGS) ) {{
-                        errno = ENOTSUP; return -1;
-                }}
-                if( !context ) {{
-                        context = __get_io_context();
-                }}
-                if(cancellation) {{
-                        cancellation->target = (__u64)(uintptr_t)&future;
-                }}
                 __u8 sflags = REGULAR_FLAGS & submit_flags;
-                struct __io_data & ring = *context->thrd.ring;
                 __u32 idx;
                 struct io_uring_sqe * sqe;
                 [(volatile struct io_uring_sqe *) sqe, idx] = __submit_alloc( ring, (__u64)(uintptr_t)&future );
+                struct $io_context * ctx = cfa_io_allocate( &sqe, &idx, 1 );
                 sqe->opcode = IORING_OP_{op};
+                sqe->user_data = (uintptr_t)&future;
                 sqe->flags = sflags;
                 sqe->ioprio = 0;
 …
                 asm volatile("": : :"memory");
                 verify( sqe->user_data == (__u64)(uintptr_t)&future );
                 __submit( context, idx );
+                verify( sqe->user_data == (uintptr_t)&future );
+                cfa_io_submit( ctx, &idx, 1, 0 != (submit_flags & CFA_IO_LAZY) );
         #endif
 }}"""
+SyncTemplate = """{ret} cfa_{name}({params}, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context) {{
+        if( timeout >= 0 ) {{
+                errno = ENOTSUP;
+                return -1;
+        }}
+SyncTemplate = """{ret} cfa_{name}({params}, __u64 submit_flags) {{
         io_future_t future;
         async_{name}( future, {args}, submit_flags, cancellation, context );
+        async_{name}( future, {args}, submit_flags );
         wait( future );
 …
                 'fd'  : 'fd',
                 'off' : 'offset',
                 'addr': '(__u64)iov',
+                'addr': '(uintptr_t)iov',
                 'len' : 'iovcnt',
         }, define = 'CFA_HAVE_PREADV2'),
 …
                 'fd'  : 'fd',
                 'off' : 'offset',
                 'addr': '(__u64)iov',
+                'addr': '(uintptr_t)iov',
                 'len' : 'iovcnt'
         }, define = 'CFA_HAVE_PWRITEV2'),
 …
                 'addr': 'fd',
                 'len': 'op',
                 'off': '(__u64)event'
+                'off': '(uintptr_t)event'
         }),
         # CFA_HAVE_IORING_OP_SYNC_FILE_RANGE
 …
         Call('SENDMSG', 'ssize_t sendmsg(int sockfd, const struct msghdr *msg, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(__u64)(struct msghdr *)msg',
+                'addr': '(uintptr_t)(struct msghdr *)msg',
                 'len': '1',
                 'msg_flags': 'flags'
 …
         Call('RECVMSG', 'ssize_t recvmsg(int sockfd, struct msghdr *msg, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(__u64)(struct msghdr *)msg',
+                'addr': '(uintptr_t)(struct msghdr *)msg',
                 'len': '1',
                 'msg_flags': 'flags'
 …
         Call('SEND', 'ssize_t send(int sockfd, const void *buf, size_t len, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(__u64)buf',
+                'addr': '(uintptr_t)buf',
                 'len': 'len',
                 'msg_flags': 'flags'
 …
         Call('RECV', 'ssize_t recv(int sockfd, void *buf, size_t len, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(__u64)buf',
+                'addr': '(uintptr_t)buf',
                 'len': 'len',
                 'msg_flags': 'flags'
 …
         Call('ACCEPT', 'int accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags)', {
                 'fd': 'sockfd',
                 'addr': '(__u64)addr',
                 'addr2': '(__u64)addrlen',
+                'addr': '(uintptr_t)addr',
+                'addr2': '(uintptr_t)addrlen',
                 'accept_flags': 'flags'
         }),
 …
         Call('CONNECT', 'int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen)', {
                 'fd': 'sockfd',
                 'addr': '(__u64)addr',
+                'addr': '(uintptr_t)addr',
                 'off': 'addrlen'
         }),
 …
         Call('FALLOCATE', 'int fallocate(int fd, int mode, off_t offset, off_t len)', {
                 'fd': 'fd',
                 'addr': '(__u64)len',
+                'addr': '(uintptr_t)len',
                 'len': 'mode',
                 'off': 'offset'
 …
         # CFA_HAVE_IORING_OP_MADVISE
         Call('MADVISE', 'int madvise(void *addr, size_t length, int advice)', {
                 'addr': '(__u64)addr',
+                'addr': '(uintptr_t)addr',
                 'len': 'length',
                 'fadvise_advice': 'advice'
 …
         Call('OPENAT', 'int openat(int dirfd, const char *pathname, int flags, mode_t mode)', {
                 'fd': 'dirfd',
                 'addr': '(__u64)pathname',
+                'addr': '(uintptr_t)pathname',
                 'len': 'mode',
                 'open_flags': 'flags;'
 …
                 'addr': 'pathname',
                 'len': 'sizeof(*how)',
                 'off': '(__u64)how',
+                'off': '(uintptr_t)how',
         }, define = 'CFA_HAVE_OPENAT2'),
         # CFA_HAVE_IORING_OP_CLOSE
 …
         Call('STATX', 'int statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf)', {
                 'fd': 'dirfd',
                 'off': '(__u64)statxbuf',
+                'off': '(uintptr_t)statxbuf',
                 'addr': 'pathname',
                 'len': 'mask',
 …
         Call('READ', 'ssize_t read(int fd, void * buf, size_t count)', {
                 'fd': 'fd',
                 'addr': '(__u64)buf',
+                'addr': '(uintptr_t)buf',
                 'len': 'count'
         }),
 …
         Call('WRITE', 'ssize_t write(int fd, void * buf, size_t count)', {
                 'fd': 'fd',
                 'addr': '(__u64)buf',
+                'addr': '(uintptr_t)buf',
                 'len': 'count'
         }),
         # CFA_HAVE_IORING_OP_SPLICE
         Call('SPLICE', 'ssize_t splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags)', {
+        Call('SPLICE', 'ssize_t splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags)', {
                 'splice_fd_in': 'fd_in',
                 'splice_off_in': 'off_in ? (__u64)*off_in : (__u64)-1',
 …
         if c.define:
                 print("""#if defined({define})
         {ret} cfa_{name}({params}, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+        {ret} cfa_{name}({params}, __u64 submit_flags);
 #endif""".format(define=c.define,ret=c.ret, name=c.name, params=c.params))
         else:
                 print("{ret} cfa_{name}({params}, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);"
+                print("{ret} cfa_{name}({params}, __u64 submit_flags);"
                 .format(ret=c.ret, name=c.name, params=c.params))
 …
         if c.define:
                 print("""#if defined({define})
         void async_{name}(io_future_t & future, {params}, int submit_flags, io_cancellation * cancellation, io_context * context);
+        void async_{name}(io_future_t & future, {params}, __u64 submit_flags);
 #endif""".format(define=c.define,name=c.name, params=c.params))
         else:
                 print("void async_{name}(io_future_t & future, {params}, int submit_flags, io_cancellation * cancellation, io_context * context);"
+                print("void async_{name}(io_future_t & future, {params}, __u64 submit_flags);"
                 .format(name=c.name, params=c.params))
 print("\n")
 …
 print("""
-//-----------------------------------------------------------------------------
-bool cancel(io_cancellation & this) {
-        #if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_ASYNC_CANCEL)
-                return false;
-        #else
-                io_future_t future;
-                io_context * context = __get_io_context();
-                __u8 sflags = 0;
-                struct __io_data & ring = *context->thrd.ring;
-                __u32 idx;
-                volatile struct io_uring_sqe * sqe;
-                [sqe, idx] = __submit_alloc( ring, (__u64)(uintptr_t)&future );
-                sqe->__pad2[0] = sqe->__pad2[1] = sqe->__pad2[2] = 0;
-                sqe->opcode = IORING_OP_ASYNC_CANCEL;
-                sqe->flags = sflags;
-                sqe->addr = this.target;
-                verify( sqe->user_data == (__u64)(uintptr_t)&future );
-                __submit( context, idx );
-                wait(future);
-                if( future.result == 0 ) return true; // Entry found
-                if( future.result == -EALREADY) return true; // Entry found but in progress
-                if( future.result == -ENOENT ) return false; // Entry not found
-                return false;
-        #endif
+}
 //-----------------------------------------------------------------------------
 // Check if a function is has asynchronous

libcfa/src/concurrency/io/setup.cfa

-              rfeacef9
+              r5407cdc
 #if !defined(CFA_HAVE_LINUX_IO_URING_H)
-        void __kernel_io_startup() {
-                // Nothing to do without io_uring
+        }
-        void __kernel_io_shutdown() {
-                // Nothing to do without io_uring
+        }
         void ?{}(io_context_params & this) {}
+        void ?{}(io_context & this, struct cluster & cl) {}
+        void ?{}(io_context & this, struct cluster & cl, const io_context_params & params) {}
+        void ^?{}(io_context & this) {}
+        void ^?{}(io_context & this, bool cluster_context) {}
+        void register_fixed_files( io_context &, int *, unsigned ) {}
+        void register_fixed_files( cluster    &, int *, unsigned ) {}
+        void  ?{}($io_context & this, struct cluster & cl) {}
+        void ^?{}($io_context & this) {}
+        void __cfa_io_start( processor * proc ) {}
+        void __cfa_io_flush( processor * proc ) {}
+        void __cfa_io_stop ( processor * proc ) {}
+        $io_arbiter * create(void) { return 0p; }
+        void destroy($io_arbiter *) {}
 #else
 …
         void ?{}(io_context_params & this) {
                 this.num_entries = 256;
-                this.num_ready = 256;
-                this.submit_aff = -1;
-                this.eager_submits = false;
-                this.poller_submits = false;
-                this.poll_submit = false;
-                this.poll_complete = false;
+        }
 …
 //=============================================================================================
-// I/O Startup / Shutdown logic + Master Poller
-//=============================================================================================
-        // IO Master poller loop forward
-        static void * iopoll_loop( __attribute__((unused)) void * args );
-        static struct {
-                      pthread_t  thrd;    // pthread handle to io poller thread
-                      void *     stack;   // pthread stack for io poller thread
-                      int        epollfd; // file descriptor to the epoll instance
-                volatile     bool run;     // Whether or not to continue
-                volatile     bool stopped; // Whether the poller has finished running
-                volatile uint64_t epoch;   // Epoch used for memory reclamation
-        } iopoll;
-        void __kernel_io_startup(void) {
-                __cfadbg_print_safe(io_core, "Kernel : Creating EPOLL instance\n" );
-                iopoll.epollfd = epoll_create1(0);
-                if (iopoll.epollfd == -1) {
-                        abort( "internal error, epoll_create1\n");
+                }
-                __cfadbg_print_safe(io_core, "Kernel : Starting io poller thread\n" );
-                iopoll.stack   = __create_pthread( &iopoll.thrd, iopoll_loop, 0p );
-                iopoll.run     = true;
-                iopoll.stopped = false;
-                iopoll.epoch   = 0;
+        }
-        void __kernel_io_shutdown(void) {
-                // Notify the io poller thread of the shutdown
-                iopoll.run = false;
-                sigval val = { 1 };
-                pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
-                // Wait for the io poller thread to finish
-                __destroy_pthread( iopoll.thrd, iopoll.stack, 0p );
-                int ret = close(iopoll.epollfd);
-                if (ret == -1) {
-                        abort( "internal error, close epoll\n");
+                }
-                // Io polling is now fully stopped
-                __cfadbg_print_safe(io_core, "Kernel : IO poller stopped\n" );
+        }
-        static void * iopoll_loop( __attribute__((unused)) void * args ) {
-                __processor_id_t id;
-                id.full_proc = false;
-                id.id = doregister(&id);
-                __cfaabi_tls.this_proc_id = &id;
-                __cfadbg_print_safe(io_core, "Kernel : IO poller thread starting\n" );
-                // Block signals to control when they arrive
-                sigset_t mask;
-                sigfillset(&mask);
-                if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
-                abort( "internal error, pthread_sigmask" );
+                }
-                sigdelset( &mask, SIGUSR1 );
-                // Create sufficient events
-                struct epoll_event events[10];
-                // Main loop
-                while( iopoll.run ) {
-                        __cfadbg_print_safe(io_core, "Kernel I/O - epoll : waiting on io_uring contexts\n");
-                        // increment the epoch to notify any deleters we are starting a new cycle
-                        __atomic_fetch_add(&iopoll.epoch, 1, __ATOMIC_SEQ_CST);
-                        // Wait for events
-                        int nfds = epoll_pwait( iopoll.epollfd, events, 10, -1, &mask );
-                        __cfadbg_print_safe(io_core, "Kernel I/O - epoll : %d io contexts events, waking up\n", nfds);
-                        // Check if an error occured
-                        if (nfds == -1) {
-                                if( errno == EINTR ) continue;
-                                abort( "internal error, pthread_sigmask" );
+                        }
-                        for(i; nfds) {
-                                $io_ctx_thread * io_ctx = ($io_ctx_thread *)(uintptr_t)events[i].data.u64;
-                                /* paranoid */ verify( io_ctx );
-                                __cfadbg_print_safe(io_core, "Kernel I/O - epoll : Unparking io poller %d (%p)\n", io_ctx->ring->fd, io_ctx);
-                                #if !defined( __CFA_NO_STATISTICS__ )
-                                        __cfaabi_tls.this_stats = io_ctx->self.curr_cluster->stats;
-                                #endif
-                                eventfd_t v;
-                                eventfd_read(io_ctx->ring->efd, &v);
-                                post( io_ctx->sem );
+                        }
+                }
-                __atomic_store_n(&iopoll.stopped, true, __ATOMIC_SEQ_CST);
-                __cfadbg_print_safe(io_core, "Kernel : IO poller thread stopping\n" );
-                unregister(&id);
-                return 0p;
+        }
-//=============================================================================================
 // I/O Context Constrution/Destruction
 //=============================================================================================
+        void ?{}($io_ctx_thread & this, struct cluster & cl) { (this.self){ "IO Poller", cl }; }
+        void main( $io_ctx_thread & this );
+        static inline $thread * get_thread( $io_ctx_thread & this ) { return &this.self; }
+        void ^?{}( $io_ctx_thread & mutex this ) {}
+        static void __io_create ( __io_data & this, const io_context_params & params_in );
+        static void __io_destroy( __io_data & this );
+        void ?{}(io_context & this, struct cluster & cl, const io_context_params & params) {
+                (this.thrd){ cl };
+                this.thrd.ring = malloc();
+                __cfadbg_print_safe(io_core, "Kernel I/O : Creating ring for io_context %p\n", &this);
+                __io_create( *this.thrd.ring, params );
+                __cfadbg_print_safe(io_core, "Kernel I/O : Starting poller thread for io_context %p\n", &this);
+                this.thrd.done = false;
+                __thrd_start( this.thrd, main );
+                __cfadbg_print_safe(io_core, "Kernel I/O : io_context %p ready\n", &this);
+        }
+        void ?{}(io_context & this, struct cluster & cl) {
+                io_context_params params;
+                (this){ cl, params };
+        }
+        void ^?{}(io_context & this, bool cluster_context) {
+                __cfadbg_print_safe(io_core, "Kernel I/O : tearing down io_context %p\n", &this);
+                // Notify the thread of the shutdown
+                __atomic_store_n(&this.thrd.done, true, __ATOMIC_SEQ_CST);
+                // If this is an io_context within a cluster, things get trickier
+                $thread & thrd = this.thrd.self;
+                if( cluster_context ) {
+                        // We are about to do weird things with the threads
+                        // we don't need interrupts to complicate everything
+                        disable_interrupts();
+                        // Get cluster info
+                        cluster & cltr = *thrd.curr_cluster;
+                        /* paranoid */ verify( cltr.idles.total == 0 || &cltr == mainCluster );
+                        /* paranoid */ verify( !ready_mutate_islocked() );
+                        // We need to adjust the clean-up based on where the thread is
+                        if( thrd.state == Ready || thrd.preempted != __NO_PREEMPTION ) {
+                                // This is the tricky case
+                                // The thread was preempted or ready to run and now it is on the ready queue
+                                // but the cluster is shutting down, so there aren't any processors to run the ready queue
+                                // the solution is to steal the thread from the ready-queue and pretend it was blocked all along
+                                ready_schedule_lock();
+                                        // The thread should on the list
+                                        /* paranoid */ verify( thrd.link.next != 0p );
+                                        // Remove the thread from the ready queue of this cluster
+                                        // The thread should be the last on the list
+                                        __attribute__((unused)) bool removed = remove_head( &cltr, &thrd );
+                                        /* paranoid */ verify( removed );
+                                        thrd.link.next = 0p;
+                                        thrd.link.prev = 0p;
+                                        // Fixup the thread state
+                                        thrd.state = Blocked;
+                                        thrd.ticket = TICKET_BLOCKED;
+                                        thrd.preempted = __NO_PREEMPTION;
+                                ready_schedule_unlock();
+                                // Pretend like the thread was blocked all along
+                        }
+                        // !!! This is not an else if !!!
+                        // Ok, now the thread is blocked (whether we cheated to get here or not)
+                        if( thrd.state == Blocked ) {
+                                // This is the "easy case"
+                                // The thread is parked and can easily be moved to active cluster
+                                verify( thrd.curr_cluster != active_cluster() || thrd.curr_cluster == mainCluster );
+                                thrd.curr_cluster = active_cluster();
+                                // unpark the fast io_poller
+                                unpark( &thrd );
+                        }
+                        else {
+                                // The thread is in a weird state
+                                // I don't know what to do here
+                                abort("io_context poller thread is in unexpected state, cannot clean-up correctly\n");
+                        }
+                        // The weird thread kidnapping stuff is over, restore interrupts.
+                        enable_interrupts( __cfaabi_dbg_ctx );
+                } else {
+                        post( this.thrd.sem );
+                }
+                ^(this.thrd){};
+                __cfadbg_print_safe(io_core, "Kernel I/O : Stopped poller thread for io_context %p\n", &this);
+                __io_destroy( *this.thrd.ring );
+                __cfadbg_print_safe(io_core, "Kernel I/O : Destroyed ring for io_context %p\n", &this);
+                free(this.thrd.ring);
+        }
+        void ^?{}(io_context & this) {
+                ^(this){ false };
+        static void __io_uring_setup ( $io_context & this, const io_context_params & params_in, int procfd );
+        static void __io_uring_teardown( $io_context & this );
+        static void __epoll_register($io_context & ctx);
+        static void __epoll_unregister($io_context & ctx);
+        void __ioarbiter_register( $io_arbiter & mutex, $io_context & ctx );
+        void __ioarbiter_unregister( $io_arbiter & mutex, $io_context & ctx );
+        void ?{}($io_context & this, processor * proc, struct cluster & cl) {
+                /* paranoid */ verify( cl.io.arbiter );
+                this.proc = proc;
+                this.arbiter = cl.io.arbiter;
+                this.ext_sq.empty = true;
+                (this.ext_sq.queue){};
+                __io_uring_setup( this, cl.io.params, proc->idle );
+                __cfadbg_print_safe(io_core, "Kernel I/O : Created ring for io_context %u (%p)\n", this.fd, &this);
+        }
+        void ^?{}($io_context & this) {
+                __cfadbg_print_safe(io_core, "Kernel I/O : tearing down io_context %u\n", this.fd);
+                __io_uring_teardown( this );
+                __cfadbg_print_safe(io_core, "Kernel I/O : Destroyed ring for io_context %u\n", this.fd);
+        }
 …
         extern void __enable_interrupts_hard();
         static void __io_create( __io_data & this, const io_context_params & params_in ) {
+        static void __io_uring_setup( $io_context & this, const io_context_params & params_in, int procfd ) {
                 // Step 1 : call to setup
                 struct io_uring_params params;
                 memset(&params, 0, sizeof(params));
                 if( params_in.poll_submit   ) params.flags |= IORING_SETUP_SQPOLL;
                 if( params_in.poll_complete ) params.flags |= IORING_SETUP_IOPOLL;
+                // if( params_in.poll_submit   ) params.flags |= IORING_SETUP_SQPOLL;
+                // if( params_in.poll_complete ) params.flags |= IORING_SETUP_IOPOLL;
                 __u32 nentries = params_in.num_entries != 0 ? params_in.num_entries : 256;
 …
                         abort("ERROR: I/O setup 'num_entries' must be a power of 2\n");
+                }
-                if( params_in.poller_submits && params_in.eager_submits ) {
-                        abort("ERROR: I/O setup 'poller_submits' and 'eager_submits' cannot be used together\n");
+                }
                 int fd = syscall(__NR_io_uring_setup, nentries, &params );
 …
                 // Step 2 : mmap result
+                memset( &this, 0, sizeof(struct __io_data) );
+                struct __submition_data  & sq = this.submit_q;
+                struct __completion_data & cq = this.completion_q;
+                struct __sub_ring_t & sq = this.sq;
+                struct __cmp_ring_t & cq = this.cq;
                 // calculate the right ring size
 …
                 // Get the pointers from the kernel to fill the structure
                 // submit queue
+                sq.head    = (volatile __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.head);
+                sq.tail    = (volatile __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.tail);
+                sq.mask    = (   const __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.ring_mask);
+                sq.num     = (   const __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.ring_entries);
+                sq.flags   = (         __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.flags);
+                sq.dropped = (         __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.dropped);
+                sq.array   = (         __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.array);
+                sq.prev_head = *sq.head;
+                {
+                        const __u32 num = *sq.num;
+                        for( i; num ) {
+                                __sqe_clean( &sq.sqes[i] );
+                        }
+                }
+                (sq.submit_lock){};
+                (sq.release_lock){};
+                if( params_in.poller_submits || params_in.eager_submits ) {
+                        /* paranoid */ verify( is_pow2( params_in.num_ready ) || (params_in.num_ready < 8) );
+                        sq.ready_cnt = max( params_in.num_ready, 8 );
+                        sq.ready = alloc( sq.ready_cnt, 64`align );
+                        for(i; sq.ready_cnt) {
+                                sq.ready[i] = -1ul32;
+                        }
+                        sq.prev_ready = 0;
+                }
+                else {
+                        sq.ready_cnt = 0;
+                        sq.ready = 0p;
+                        sq.prev_ready = 0;
+                }
+                sq.kring.head  = (volatile __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.head);
+                sq.kring.tail  = (volatile __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.tail);
+                sq.kring.array = (         __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.array);
+                sq.mask        = (   const __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.ring_mask);
+                sq.num         = (   const __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.ring_entries);
+                sq.flags       = (         __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.flags);
+                sq.dropped     = (         __u32 *)(((intptr_t)sq.ring_ptr) + params.sq_off.dropped);
+                sq.kring.released = 0;
+                sq.free_ring.head = 0;
+                sq.free_ring.tail = *sq.num;
+                sq.free_ring.array = alloc( *sq.num, 128`align );
+                for(i; (__u32)*sq.num) {
+                        sq.free_ring.array[i] = i;
+                }
+                sq.to_submit = 0;
                 // completion queue
 …
                 // io_uring_register is so f*cking slow on some machine that it
                 // will never succeed if preemption isn't hard blocked
+                __cfadbg_print_safe(io_core, "Kernel I/O : registering %d for completion with ring %d\n", procfd, fd);
                 __disable_interrupts_hard();
+                int efd = eventfd(0, 0);
+                if (efd < 0) {
+                        abort("KERNEL ERROR: IO_URING EVENTFD - %s\n", strerror(errno));
+                }
+                int ret = syscall( __NR_io_uring_register, fd, IORING_REGISTER_EVENTFD, &efd, 1);
+                int ret = syscall( __NR_io_uring_register, fd, IORING_REGISTER_EVENTFD, &procfd, 1);
                 if (ret < 0) {
                         abort("KERNEL ERROR: IO_URING EVENTFD REGISTER - %s\n", strerror(errno));
 …
                 __enable_interrupts_hard();
+                __cfadbg_print_safe(io_core, "Kernel I/O : registered %d for completion with ring %d\n", procfd, fd);
                 // some paranoid checks
 …
                 /* paranoid */ verifyf( (*sq.mask) == ((*sq.num) - 1ul32), "IO_URING Expected mask to be %u (%u entries), was %u", (*sq.num) - 1ul32, *sq.num, *sq.mask );
                 /* paranoid */ verifyf( (*sq.num) >= nentries, "IO_URING Expected %u entries, got %u", nentries, *sq.num );
                 /* paranoid */ verifyf( (*sq.head) == 0, "IO_URING Expected head to be 0, got %u", *sq.head );
                 /* paranoid */ verifyf( (*sq.tail) == 0, "IO_URING Expected tail to be 0, got %u", *sq.tail );
+                /* paranoid */ verifyf( (*sq.kring.head) == 0, "IO_URING Expected head to be 0, got %u", *sq.kring.head );
+                /* paranoid */ verifyf( (*sq.kring.tail) == 0, "IO_URING Expected tail to be 0, got %u", *sq.kring.tail );
                 // Update the global ring info
                 this.ring_flags = params.flags;
+                this.ring_flags = 0;
                 this.fd         = fd;
+                this.efd        = efd;
+                this.eager_submits  = params_in.eager_submits;
+                this.poller_submits = params_in.poller_submits;
+        }
+        static void __io_destroy( __io_data & this ) {
+        }
+        static void __io_uring_teardown( $io_context & this ) {
                 // Shutdown the io rings
                 struct __submition_data  & sq = this.submit_q;
                 struct __completion_data & cq = this.completion_q;
+                struct __sub_ring_t & sq = this.sq;
+                struct __cmp_ring_t & cq = this.cq;
                 // unmap the submit queue entries
 …
                 // close the file descriptor
                 close(this.fd);
+                close(this.efd);
+                free( this.submit_q.ready ); // Maybe null, doesn't matter
+                free( this.sq.free_ring.array ); // Maybe null, doesn't matter
+        }
+        void __cfa_io_start( processor * proc ) {
+                proc->io.ctx = alloc();
+                (*proc->io.ctx){proc, *proc->cltr};
+        }
+        void __cfa_io_stop ( processor * proc ) {
+                ^(*proc->io.ctx){};
+                free(proc->io.ctx);
+        }
 …
 // I/O Context Sleep
 //=============================================================================================
+        static inline void __ioctx_epoll_ctl($io_ctx_thread & ctx, int op, const char * error) {
+                struct epoll_event ev;
+                ev.events = EPOLLIN | EPOLLONESHOT;
+                ev.data.u64 = (__u64)&ctx;
+                int ret = epoll_ctl(iopoll.epollfd, op, ctx.ring->efd, &ev);
+                if (ret < 0) {
+                        abort( "KERNEL ERROR: EPOLL %s - (%d) %s\n", error, (int)errno, strerror(errno) );
+                }
+        }
+        void __ioctx_register($io_ctx_thread & ctx) {
+                __ioctx_epoll_ctl(ctx, EPOLL_CTL_ADD, "ADD");
+        }
+        void __ioctx_prepare_block($io_ctx_thread & ctx) {
+                __cfadbg_print_safe(io_core, "Kernel I/O - epoll : Re-arming io poller %d (%p)\n", ctx.ring->fd, &ctx);
+                __ioctx_epoll_ctl(ctx, EPOLL_CTL_MOD, "REARM");
+        }
+        void __ioctx_unregister($io_ctx_thread & ctx) {
+                // Read the current epoch so we know when to stop
+                size_t curr = __atomic_load_n(&iopoll.epoch, __ATOMIC_SEQ_CST);
+                // Remove the fd from the iopoller
+                __ioctx_epoll_ctl(ctx, EPOLL_CTL_DEL, "REMOVE");
+                // Notify the io poller thread of the shutdown
+                iopoll.run = false;
+                sigval val = { 1 };
+                pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
+                // Make sure all this is done
+                __atomic_thread_fence(__ATOMIC_SEQ_CST);
+                // Wait for the next epoch
+                while(curr == iopoll.epoch && !iopoll.stopped) Pause();
+        }
+        // static inline void __epoll_ctl($io_context & ctx, int op, const char * error) {
+        //      struct epoll_event ev;
+        //      ev.events = EPOLLIN | EPOLLONESHOT;
+        //      ev.data.u64 = (__u64)&ctx;
+        //      int ret = epoll_ctl(iopoll.epollfd, op, ctx.efd, &ev);
+        //      if (ret < 0) {
+        //              abort( "KERNEL ERROR: EPOLL %s - (%d) %s\n", error, (int)errno, strerror(errno) );
+        //      }
+        // }
+        // static void __epoll_register($io_context & ctx) {
+        //      __epoll_ctl(ctx, EPOLL_CTL_ADD, "ADD");
+        // }
+        // static void __epoll_unregister($io_context & ctx) {
+        //      // Read the current epoch so we know when to stop
+        //      size_t curr = __atomic_load_n(&iopoll.epoch, __ATOMIC_SEQ_CST);
+        //      // Remove the fd from the iopoller
+        //      __epoll_ctl(ctx, EPOLL_CTL_DEL, "REMOVE");
+        //      // Notify the io poller thread of the shutdown
+        //      iopoll.run = false;
+        //      sigval val = { 1 };
+        //      pthread_sigqueue( iopoll.thrd, SIGUSR1, val );
+        //      // Make sure all this is done
+        //      __atomic_thread_fence(__ATOMIC_SEQ_CST);
+        //      // Wait for the next epoch
+        //      while(curr == iopoll.epoch && !iopoll.stopped) Pause();
+        // }
+        // void __ioctx_prepare_block($io_context & ctx) {
+        //      __cfadbg_print_safe(io_core, "Kernel I/O - epoll : Re-arming io poller %d (%p)\n", ctx.fd, &ctx);
+        //      __epoll_ctl(ctx, EPOLL_CTL_MOD, "REARM");
+        // }
 //=============================================================================================
 // I/O Context Misc Setup
 //=============================================================================================
+        void register_fixed_files( io_context & ctx, int * files, unsigned count ) {
+                int ret = syscall( __NR_io_uring_register, ctx.thrd.ring->fd, IORING_REGISTER_FILES, files, count );
+                if( ret < 0 ) {
+                        abort( "KERNEL ERROR: IO_URING REGISTER - (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                __cfadbg_print_safe( io_core, "Kernel I/O : Performed io_register for %p, returned %d\n", active_thread(), ret );
+        }
+        void register_fixed_files( cluster & cltr, int * files, unsigned count ) {
+                for(i; cltr.io.cnt) {
+                        register_fixed_files( cltr.io.ctxs[i], files, count );
+                }
+        }
+        void ?{}( $io_arbiter & this ) {
+                this.pending.empty = true;
+        }
+        void ^?{}( $io_arbiter & this ) {}
+        $io_arbiter * create(void) {
+                return new();
+        }
+        void destroy($io_arbiter * arbiter) {
+                delete(arbiter);
+        }
+//=============================================================================================
+// I/O Context Misc Setup
+//=============================================================================================
 #endif

libcfa/src/concurrency/io/types.hfa

-              rfeacef9
+              r5407cdc
 #include "bits/locks.hfa"
+#include "bits/queue.hfa"
 #include "kernel/fwd.hfa"
 #if defined(CFA_HAVE_LINUX_IO_URING_H)
+        #define LEADER_LOCK
+        struct __leaderlock_t {
+                struct $thread * volatile value;        // ($thread) next_leader | (bool:1) is_locked
+        };
+        #include "bits/sequence.hfa"
+        #include "monitor.hfa"
+        static inline void ?{}( __leaderlock_t & this ) { this.value = 0p; }
+        struct processor;
+        monitor $io_arbiter;
         //-----------------------------------------------------------------------
         // Ring Data structure
+      struct __submition_data {
+                // Head and tail of the ring (associated with array)
+                volatile __u32 * head;
+                volatile __u32 * tail;
+                volatile __u32 prev_head;
+      struct __sub_ring_t {
+                struct {
+                        // Head and tail of the ring (associated with array)
+                        volatile __u32 * head;   // one passed last index consumed by the kernel
+                        volatile __u32 * tail;   // one passed last index visible to the kernel
+                        volatile __u32 released; // one passed last index released back to the free list
+                // The actual kernel ring which uses head/tail
+                // indexes into the sqes arrays
+                __u32 * array;
+                        // The actual kernel ring which uses head/tail
+                        // indexes into the sqes arrays
+                        __u32 * array;
+                } kring;
+                struct {
+                        volatile __u32 head;
+                        volatile __u32 tail;
+                        // The ring which contains free allocations
+                        // indexes into the sqes arrays
+                        __u32 * array;
+                } free_ring;
+                // number of sqes to submit on next system call.
+                __u32 to_submit;
                 // number of entries and mask to go with it
 …
                 const __u32 * mask;
                 // Submission flags (Not sure what for)
+                // Submission flags, currently only IORING_SETUP_SQPOLL
                 __u32 * flags;
+                // number of sqes not submitted (whatever that means)
+                // number of sqes not submitted
+                // From documentation : [dropped] is incremented for each invalid submission queue entry encountered in the ring buffer.
                 __u32 * dropped;
-                // Like head/tail but not seen by the kernel
-                volatile __u32 * ready;
-                __u32 ready_cnt;
-                __u32 prev_ready;
-                #if defined(LEADER_LOCK)
-                        __leaderlock_t submit_lock;
-                #else
-                        __spinlock_t submit_lock;
-                #endif
-                __spinlock_t  release_lock;
                 // A buffer of sqes (not the actual ring)
                 volatile struct io_uring_sqe * sqes;
+                struct io_uring_sqe * sqes;
                 // The location and size of the mmaped area
 …
         };
         struct __completion_data {
+        struct __cmp_ring_t {
                 // Head and tail of the ring
                 volatile __u32 * head;
 …
                 const __u32 * num;
                 // number of cqes not submitted (whatever that means)
+                // I don't know what this value is for
                 __u32 * overflow;
 …
         };
+        struct __io_data {
+                struct __submition_data submit_q;
+                struct __completion_data completion_q;
+        struct __outstanding_io {
+                inline Colable;
+                single_sem sem;
+        };
+        static inline __outstanding_io *& Next( __outstanding_io * n ) { return (__outstanding_io *)Next( (Colable *)n ); }
+        struct __outstanding_io_queue {
+                __spinlock_t lock;
+                Queue(__outstanding_io) queue;
+                volatile bool empty;
+        };
+        struct __external_io {
+                inline __outstanding_io;
+                __u32 * idxs;
+                __u32 have;
+                bool lazy;
+        };
+        struct __attribute__((aligned(128))) $io_context {
+                $io_arbiter * arbiter;
+                processor * proc;
+                __outstanding_io_queue ext_sq;
+                struct __sub_ring_t sq;
+                struct __cmp_ring_t cq;
                 __u32 ring_flags;
                 int fd;
+                int efd;
+                bool eager_submits:1;
+                bool poller_submits:1;
+        };
+        struct __pending_alloc {
+                inline __outstanding_io;
+                __u32 * idxs;
+                __u32 want;
+                $io_context * ctx;
+        };
+        struct __attribute__((aligned(128))) $io_arbiter {
+                __outstanding_io_queue pending;
         };
 …
         #endif
+        struct $io_ctx_thread;
+        void __ioctx_register($io_ctx_thread & ctx);
+        void __ioctx_unregister($io_ctx_thread & ctx);
+        void __ioctx_prepare_block($io_ctx_thread & ctx);
+        void __sqe_clean( volatile struct io_uring_sqe * sqe );
+        // void __ioctx_prepare_block($io_context & ctx);
 #endif
 …
 static inline {
         bool fulfil( io_future_t & this, __s32 result ) {
+        $thread * fulfil( io_future_t & this, __s32 result, bool do_unpark = true ) {
                 this.result = result;
                 return fulfil(this.self);
+                return fulfil(this.self, do_unpark);
+        }

libcfa/src/concurrency/iofwd.hfa

-              rfeacef9
+              r5407cdc
 #include <unistd.h>
 extern "C" {
         #include <sys/types.h>
+        #include <asm/types.h>
         #if CFA_HAVE_LINUX_IO_URING_H
                 #include <linux/io_uring.h>
 …
 struct cluster;
 struct io_future_t;
+struct io_context;
+struct io_cancellation;
+struct $io_context;
 struct iovec;
 …
 struct sockaddr;
 struct statx;
+struct epoll_event;
+struct io_uring_sqe;
+//----------
+// underlying calls
+extern struct $io_context * cfa_io_allocate(struct io_uring_sqe * out_sqes[], __u32 out_idxs[], __u32 want)  __attribute__((nonnull (1,2)));
+extern void cfa_io_submit( struct $io_context * in_ctx, __u32 in_idxs[], __u32 have, bool lazy ) __attribute__((nonnull (1,2)));
 //----------
 // synchronous calls
 #if defined(CFA_HAVE_PREADV2)
         extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+        extern ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         extern ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+        extern ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 extern int cfa_fsync(int fd, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern  ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_fallocate(int fd, int mode, off_t offset, off_t len, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_posix_fadvise(int fd, off_t offset, off_t len, int advice, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_madvise(void *addr, size_t length, int advice, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_fsync(int fd, __u64 submit_flags);
+extern int cfa_epoll_ctl(int epfd, int op, int fd, struct epoll_event *event, __u64 submit_flags);
+extern int cfa_sync_file_range(int fd, off64_t offset, off64_t nbytes, unsigned int flags, __u64 submit_flags);
+extern  ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags, __u64 submit_flags);
+extern ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags, __u64 submit_flags);
+extern ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags);
+extern ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags, __u64 submit_flags);
+extern int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags);
+extern int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags);
+extern int cfa_fallocate(int fd, int mode, off_t offset, off_t len, __u64 submit_flags);
+extern int cfa_posix_fadvise(int fd, off_t offset, off_t len, int advice, __u64 submit_flags);
+extern int cfa_madvise(void *addr, size_t length, int advice, __u64 submit_flags);
+extern int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode, __u64 submit_flags);
 #if defined(CFA_HAVE_OPENAT2)
         extern int cfa_openat2(int dirfd, const char *pathname, struct open_how * how, size_t size, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+        extern int cfa_openat2(int dirfd, const char *pathname, struct open_how * how, size_t size, __u64 submit_flags);
 #endif
 extern int cfa_close(int fd, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern int cfa_close(int fd, __u64 submit_flags);
 #if defined(CFA_HAVE_STATX)
         extern int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+        extern int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, __u64 submit_flags);
 #endif
 extern ssize_t cfa_read(int fd, void * buf, size_t count, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern ssize_t cfa_write(int fd, void * buf, size_t count, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern ssize_t cfa_splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
 extern ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags, int submit_flags, Duration timeout, io_cancellation * cancellation, io_context * context);
+extern ssize_t cfa_read(int fd, void * buf, size_t count, __u64 submit_flags);
+extern ssize_t cfa_write(int fd, void * buf, size_t count, __u64 submit_flags);
+extern ssize_t cfa_splice(int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags, __u64 submit_flags);
+extern ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags, __u64 submit_flags);
 //----------
 // asynchronous calls
 #if defined(CFA_HAVE_PREADV2)
         extern void async_preadv2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+        extern void async_preadv2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 #if defined(CFA_HAVE_PWRITEV2)
         extern void async_pwritev2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+        extern void async_pwritev2(io_future_t & future, int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags, __u64 submit_flags);
 #endif
 extern void async_fsync(io_future_t & future, int fd, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_epoll_ctl(io_future_t & future, int epfd, int op, int fd, struct epoll_event *event, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_sync_file_range(io_future_t & future, int fd, off64_t offset, off64_t nbytes, unsigned int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_sendmsg(io_future_t & future, int sockfd, const struct msghdr *msg, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_recvmsg(io_future_t & future, int sockfd, struct msghdr *msg, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_send(io_future_t & future, int sockfd, const void *buf, size_t len, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_recv(io_future_t & future, int sockfd, void *buf, size_t len, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_accept4(io_future_t & future, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_connect(io_future_t & future, int sockfd, const struct sockaddr *addr, socklen_t addrlen, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_fallocate(io_future_t & future, int fd, int mode, off_t offset, off_t len, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_posix_fadvise(io_future_t & future, int fd, off_t offset, off_t len, int advice, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_madvise(io_future_t & future, void *addr, size_t length, int advice, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_openat(io_future_t & future, int dirfd, const char *pathname, int flags, mode_t mode, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_fsync(io_future_t & future, int fd, __u64 submit_flags);
+extern void async_epoll_ctl(io_future_t & future, int epfd, int op, int fd, struct epoll_event *event, __u64 submit_flags);
+extern void async_sync_file_range(io_future_t & future, int fd, off64_t offset, off64_t nbytes, unsigned int flags, __u64 submit_flags);
+extern void async_sendmsg(io_future_t & future, int sockfd, const struct msghdr *msg, int flags, __u64 submit_flags);
+extern void async_recvmsg(io_future_t & future, int sockfd, struct msghdr *msg, int flags, __u64 submit_flags);
+extern void async_send(io_future_t & future, int sockfd, const void *buf, size_t len, int flags, __u64 submit_flags);
+extern void async_recv(io_future_t & future, int sockfd, void *buf, size_t len, int flags, __u64 submit_flags);
+extern void async_accept4(io_future_t & future, int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags, __u64 submit_flags);
+extern void async_connect(io_future_t & future, int sockfd, const struct sockaddr *addr, socklen_t addrlen, __u64 submit_flags);
+extern void async_fallocate(io_future_t & future, int fd, int mode, off_t offset, off_t len, __u64 submit_flags);
+extern void async_posix_fadvise(io_future_t & future, int fd, off_t offset, off_t len, int advice, __u64 submit_flags);
+extern void async_madvise(io_future_t & future, void *addr, size_t length, int advice, __u64 submit_flags);
+extern void async_openat(io_future_t & future, int dirfd, const char *pathname, int flags, mode_t mode, __u64 submit_flags);
 #if defined(CFA_HAVE_OPENAT2)
         extern void async_openat2(io_future_t & future, int dirfd, const char *pathname, struct open_how * how, size_t size, int submit_flags, io_cancellation * cancellation, io_context * context);
+        extern void async_openat2(io_future_t & future, int dirfd, const char *pathname, struct open_how * how, size_t size, __u64 submit_flags);
 #endif
 extern void async_close(io_future_t & future, int fd, int submit_flags, io_cancellation * cancellation, io_context * context);
+extern void async_close(io_future_t & future, int fd, __u64 submit_flags);
 #if defined(CFA_HAVE_STATX)
         extern void async_statx(io_future_t & future, int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, int submit_flags, io_cancellation * cancellation, io_context * context);
+        extern void async_statx(io_future_t & future, int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf, __u64 submit_flags);
 #endif
 void async_read(io_future_t & future, int fd, void * buf, size_t count, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_write(io_future_t & future, int fd, void * buf, size_t count, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_splice(io_future_t & future, int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
 extern void async_tee(io_future_t & future, int fd_in, int fd_out, size_t len, unsigned int flags, int submit_flags, io_cancellation * cancellation, io_context * context);
+void async_read(io_future_t & future, int fd, void * buf, size_t count, __u64 submit_flags);
+extern void async_write(io_future_t & future, int fd, void * buf, size_t count, __u64 submit_flags);
+extern void async_splice(io_future_t & future, int fd_in, __off64_t *off_in, int fd_out, __off64_t *off_out, size_t len, unsigned int flags, __u64 submit_flags);
+extern void async_tee(io_future_t & future, int fd_in, int fd_out, size_t len, unsigned int flags, __u64 submit_flags);
 …
 // Check if a function is blocks a only the user thread
 bool has_user_level_blocking( fptr_t func );
-//-----------------------------------------------------------------------------
-void register_fixed_files( io_context & ctx , int * files, unsigned count );
-void register_fixed_files( cluster    & cltr, int * files, unsigned count );

libcfa/src/concurrency/kernel.cfa

-              rfeacef9
+              r5407cdc
 #include <signal.h>
 #include <unistd.h>
+extern "C" {
+        #include <sys/eventfd.h>
+}
 //CFA Includes
 …
 #include "invoke.h"
+#if !defined(__CFA_NO_STATISTICS__)
+        #define __STATS( ...) __VA_ARGS__
+#else
+        #define __STATS( ...)
+#endif
 //-----------------------------------------------------------------------------
 …
 static $thread * __next_thread(cluster * this);
 static $thread * __next_thread_slow(cluster * this);
+static inline bool __must_unpark( $thread * thrd ) __attribute((nonnull(1)));
 static void __run_thread(processor * this, $thread * dst);
 static void __wake_one(cluster * cltr);
+static void push  (__cluster_idles & idles, processor & proc);
+static void remove(__cluster_idles & idles, processor & proc);
+static [unsigned idle, unsigned total, * processor] query( & __cluster_idles idles );
+static void mark_idle (__cluster_proc_list & idles, processor & proc);
+static void mark_awake(__cluster_proc_list & idles, processor & proc);
+static [unsigned idle, unsigned total, * processor] query_idles( & __cluster_proc_list idles );
+extern void __cfa_io_start( processor * );
+extern bool __cfa_io_drain( processor * );
+extern void __cfa_io_flush( processor * );
+extern void __cfa_io_stop ( processor * );
+static inline bool __maybe_io_drain( processor * );
+extern void __disable_interrupts_hard();
+extern void __enable_interrupts_hard();
+static inline void __disable_interrupts_checked() {
+        /* paranoid */ verify( __preemption_enabled() );
+        disable_interrupts();
+        /* paranoid */ verify( ! __preemption_enabled() );
+}
+static inline void __enable_interrupts_checked( bool poll = true ) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        enable_interrupts( poll );
+        /* paranoid */ verify( __preemption_enabled() );
+}
 //=============================================================================================
 …
         verify(this);
+        __cfa_io_start( this );
         __cfadbg_print_safe(runtime_core, "Kernel : core %p starting\n", this);
         #if !defined(__CFA_NO_STATISTICS__)
 …
                 preemption_scope scope = { this };
+                #if !defined(__CFA_NO_STATISTICS__)
+                        unsigned long long last_tally = rdtscl();
+                #endif
+                __STATS( unsigned long long last_tally = rdtscl(); )
+                // if we need to run some special setup, now is the time to do it.
+                if(this->init.thrd) {
+                        this->init.thrd->curr_cluster = this->cltr;
+                        __run_thread(this, this->init.thrd);
+                }
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);
 …
                 MAIN_LOOP:
                 for() {
+                        // Check if there is pending io
+                        __maybe_io_drain( this );
                         // Try to get the next thread
                         readyThread = __next_thread( this->cltr );
                         if( !readyThread ) {
+                                __cfa_io_flush( this );
                                 readyThread = __next_thread_slow( this->cltr );
+                        }
 …
                                 // Push self to idle stack
                                 push(this->cltr->idles, * this);
+                                mark_idle(this->cltr->procs, * this);
                                 // Confirm the ready-queue is empty
 …
                                 if( readyThread ) {
                                         // A thread was found, cancel the halt
                                         remove(this->cltr->idles, * this);
+                                        mark_awake(this->cltr->procs, * this);
                                         #if !defined(__CFA_NO_STATISTICS__)
 …
                                 #endif
+                                wait( this->idle );
+                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+                                __disable_interrupts_hard();
+                                eventfd_t val;
+                                eventfd_read( this->idle, &val );
+                                __enable_interrupts_hard();
                                 #if !defined(__CFA_NO_STATISTICS__)
 …
                                 // We were woken up, remove self from idle
                                 remove(this->cltr->idles, * this);
+                                mark_awake(this->cltr->procs, * this);
                                 // DON'T just proceed, start looking again
 …
                         /* paranoid */ verify( readyThread );
+                        // Reset io dirty bit
+                        this->io.dirty = false;
                         // We found a thread run it
 …
+                                }
                         #endif
+                        if(this->io.pending && !this->io.dirty) {
+                                __cfa_io_flush( this );
+                        }
+                //      SEARCH: {
+                //              /* paranoid */ verify( ! __preemption_enabled() );
+                //              /* paranoid */ verify( kernelTLS().this_proc_id );
+                //              // First, lock the scheduler since we are searching for a thread
+                //              // Try to get the next thread
+                //              ready_schedule_lock();
+                //              readyThread = pop_fast( this->cltr );
+                //              ready_schedule_unlock();
+                //              if(readyThread) {  break SEARCH; }
+                //              // If we can't find a thread, might as well flush any outstanding I/O
+                //              if(this->io.pending) { __cfa_io_flush( this ); }
+                //              // Spin a little on I/O, just in case
+                //              for(25) {
+                //                      __maybe_io_drain( this );
+                //                      ready_schedule_lock();
+                //                      readyThread = pop_fast( this->cltr );
+                //                      ready_schedule_unlock();
+                //                      if(readyThread) {  break SEARCH; }
+                //              }
+                //              // no luck, try stealing a few times
+                //              for(25) {
+                //                      if( __maybe_io_drain( this ) ) {
+                //                              ready_schedule_lock();
+                //                              readyThread = pop_fast( this->cltr );
+                //                      } else {
+                //                              ready_schedule_lock();
+                //                              readyThread = pop_slow( this->cltr );
+                //                      }
+                //                      ready_schedule_unlock();
+                //                      if(readyThread) {  break SEARCH; }
+                //              }
+                //              // still no luck, search for a thread
+                //              ready_schedule_lock();
+                //              readyThread = pop_search( this->cltr );
+                //              ready_schedule_unlock();
+                //              if(readyThread) { break SEARCH; }
+                //              // Don't block if we are done
+                //              if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
+                //              __STATS( __tls_stats()->ready.sleep.halts++; )
+                //              // Push self to idle stack
+                //              mark_idle(this->cltr->procs, * this);
+                //              // Confirm the ready-queue is empty
+                //              __maybe_io_drain( this );
+                //              ready_schedule_lock();
+                //              readyThread = pop_search( this->cltr );
+                //              ready_schedule_unlock();
+                //              if( readyThread ) {
+                //                      // A thread was found, cancel the halt
+                //                      mark_awake(this->cltr->procs, * this);
+                //                      __STATS( __tls_stats()->ready.sleep.cancels++; )
+                //                      // continue the main loop
+                //                      break SEARCH;
+                //              }
+                //              __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->id, rdtscl()); )
+                //              __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+                //              // __disable_interrupts_hard();
+                //              eventfd_t val;
+                //              eventfd_read( this->idle, &val );
+                //              // __enable_interrupts_hard();
+                //              __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->id, rdtscl()); )
+                //              // We were woken up, remove self from idle
+                //              mark_awake(this->cltr->procs, * this);
+                //              // DON'T just proceed, start looking again
+                //              continue MAIN_LOOP;
+                //      }
+                // RUN_THREAD:
+                //      /* paranoid */ verify( kernelTLS().this_proc_id );
+                //      /* paranoid */ verify( ! __preemption_enabled() );
+                //      /* paranoid */ verify( readyThread );
+                //      // Reset io dirty bit
+                //      this->io.dirty = false;
+                //      // We found a thread run it
+                //      __run_thread(this, readyThread);
+                //      // Are we done?
+                //      if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
+                //      #if !defined(__CFA_NO_STATISTICS__)
+                //              unsigned long long curr = rdtscl();
+                //              if(curr > (last_tally + 500000000)) {
+                //                      __tally_stats(this->cltr->stats, __cfaabi_tls.this_stats);
+                //                      last_tally = curr;
+                //              }
+                //      #endif
+                //      if(this->io.pending && !this->io.dirty) {
+                //              __cfa_io_flush( this );
+                //      }
+                //      // Check if there is pending io
+                //      __maybe_io_drain( this );
+                }
 …
+        }
+        __cfa_io_stop( this );
         post( this->terminated );
         if(this == mainProcessor) {
 …
         /* paranoid */ verifyf( thrd_dst->link.next == 0p, "Expected null got %p", thrd_dst->link.next );
         __builtin_prefetch( thrd_dst->context.SP );
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p running thread %p (%s)\n", this, thrd_dst, thrd_dst->self_cor.name);
         $coroutine * proc_cor = get_coroutine(this->runner);
 …
                 if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
                         // The thread was preempted, reschedule it and reset the flag
                         __schedule_thread( thrd_dst );
+                        schedule_thread$( thrd_dst );
                         break RUNNING;
+                }
 …
                                 break RUNNING;
                         case TICKET_UNBLOCK:
+                                #if !defined(__CFA_NO_STATISTICS__)
+                                        __tls_stats()->ready.threads.threads++;
+                                        __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", this );
+                                #endif
                                 // This is case 2, the racy case, someone tried to run this thread before it finished blocking
                                 // In this case, just run it again.
 …
         proc_cor->state = Active;
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p finished running thread %p\n", this, thrd_dst);
+        #if !defined(__CFA_NO_STATISTICS__)
+                __tls_stats()->ready.threads.threads--;
+                __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", this );
+        #endif
         /* paranoid */ verify( ! __preemption_enabled() );
+}
 …
         $thread * thrd_src = kernelTLS().this_thread;
+        #if !defined(__CFA_NO_STATISTICS__)
+                struct processor * last_proc = kernelTLS().this_processor;
+        #endif
+        __STATS( thrd_src->last_proc = kernelTLS().this_processor; )
         // Run the thread on this processor
 …
         #if !defined(__CFA_NO_STATISTICS__)
+                if(last_proc != kernelTLS().this_processor) {
+                /* paranoid */ verify( thrd_src->last_proc != 0p );
+                if(thrd_src->last_proc != kernelTLS().this_processor) {
                         __tls_stats()->ready.threads.migration++;
+                }
 …
 // Scheduler routines
 // KERNEL ONLY
 void __schedule_thread( $thread * thrd ) {
+static void __schedule_thread( $thread * thrd ) {
         /* paranoid */ verify( ! __preemption_enabled() );
         /* paranoid */ verify( kernelTLS().this_proc_id );
+        /* paranoid */ verify( ready_schedule_islocked());
         /* paranoid */ verify( thrd );
         /* paranoid */ verify( thrd->state != Halted );
 …
         if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
+        // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
+        struct cluster * cl = thrd->curr_cluster;
+        __STATS(bool outside = thrd->last_proc && thrd->last_proc != kernelTLS().this_processor; )
+        // push the thread to the cluster ready-queue
+        push( cl, thrd );
+        // variable thrd is no longer safe to use
+        thrd = 0xdeaddeaddeaddeadp;
+        // wake the cluster using the save variable.
+        __wake_one( cl );
+        #if !defined(__CFA_NO_STATISTICS__)
+                if( kernelTLS().this_stats ) {
+                        __tls_stats()->ready.threads.threads++;
+                        if(outside) {
+                                __tls_stats()->ready.threads.extunpark++;
+                        }
+                        __push_stat( __tls_stats(), __tls_stats()->ready.threads.threads, false, "Processor", kernelTLS().this_processor );
+                }
+                else {
+                        __atomic_fetch_add(&cl->stats->ready.threads.threads, 1, __ATOMIC_RELAXED);
+                        __atomic_fetch_add(&cl->stats->ready.threads.extunpark, 1, __ATOMIC_RELAXED);
+                        __push_stat( cl->stats, cl->stats->ready.threads.threads, true, "Cluster", cl );
+                }
+        #endif
+        /* paranoid */ verify( ready_schedule_islocked());
+        /* paranoid */ verify( ! __preemption_enabled() );
+}
+void schedule_thread$( $thread * thrd ) {
         ready_schedule_lock();
+                // Dereference the thread now because once we push it, there is not guaranteed it's still valid.
+                struct cluster * cl = thrd->curr_cluster;
+                // push the thread to the cluster ready-queue
+                push( cl, thrd );
+                // variable thrd is no longer safe to use
+                // wake the cluster using the save variable.
+                __wake_one( cl );
+                __schedule_thread( thrd );
         ready_schedule_unlock();
-        /* paranoid */ verify( ! __preemption_enabled() );
+}
 …
         ready_schedule_lock();
                 $thread * thrd = pop( this );
+                $thread * thrd = pop_fast( this );
         ready_schedule_unlock();
 …
         ready_schedule_lock();
+                $thread * thrd = pop_slow( this );
+                $thread * thrd;
+                for(25) {
+                        thrd = pop_slow( this );
+                        if(thrd) goto RET;
+                }
+                thrd = pop_search( this );
+                RET:
         ready_schedule_unlock();
 …
+}
+void unpark( $thread * thrd ) {
+        if( !thrd ) return;
+static inline bool __must_unpark( $thread * thrd ) {
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
         switch(old_ticket) {
                 case TICKET_RUNNING:
                         // Wake won the race, the thread will reschedule/rerun itself
                         break;
+                        return false;
                 case TICKET_BLOCKED:
                         /* paranoid */ verify( ! thrd->preempted != __NO_PREEMPTION );
                         /* paranoid */ verify( thrd->state == Blocked );
+                        {
+                                /* paranoid */ verify( publicTLS_get(this_proc_id) );
+                                bool full = publicTLS_get(this_proc_id)->full_proc;
+                                if(full) disable_interrupts();
+                                /* paranoid */ verify( ! __preemption_enabled() );
+                                // Wake lost the race,
+                                __schedule_thread( thrd );
+                                /* paranoid */ verify( ! __preemption_enabled() );
+                                if(full) enable_interrupts( __cfaabi_dbg_ctx );
+                                /* paranoid */ verify( publicTLS_get(this_proc_id) );
+                        }
+                        break;
+                        return true;
                 default:
                         // This makes no sense, something is wrong abort
 …
+}
+void __kernel_unpark( $thread * thrd ) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        /* paranoid */ verify( ready_schedule_islocked());
+        if( !thrd ) return;
+        if(__must_unpark(thrd)) {
+                // Wake lost the race,
+                __schedule_thread( thrd );
+        }
+        /* paranoid */ verify( ready_schedule_islocked());
+        /* paranoid */ verify( ! __preemption_enabled() );
+}
+void unpark( $thread * thrd ) {
+        if( !thrd ) return;
+        if(__must_unpark(thrd)) {
+                disable_interrupts();
+                        // Wake lost the race,
+                        schedule_thread$( thrd );
+                enable_interrupts(false);
+        }
+}
 void park( void ) {
+        /* paranoid */ verify( __preemption_enabled() );
+        disable_interrupts();
+        /* paranoid */ verify( ! __preemption_enabled() );
+        /* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
+        returnToKernel();
+        /* paranoid */ verify( ! __preemption_enabled() );
+        enable_interrupts( __cfaabi_dbg_ctx );
+        /* paranoid */ verify( __preemption_enabled() );
+        __disable_interrupts_checked();
+                /* paranoid */ verify( kernelTLS().this_thread->preempted == __NO_PREEMPTION );
+                returnToKernel();
+        __enable_interrupts_checked();
+}
 …
 // KERNEL ONLY
 bool force_yield( __Preemption_Reason reason ) {
+        /* paranoid */ verify( __preemption_enabled() );
+        disable_interrupts();
+        /* paranoid */ verify( ! __preemption_enabled() );
+        $thread * thrd = kernelTLS().this_thread;
+        /* paranoid */ verify(thrd->state == Active);
+        // SKULLDUGGERY: It is possible that we are preempting this thread just before
+        // it was going to park itself. If that is the case and it is already using the
+        // intrusive fields then we can't use them to preempt the thread
+        // If that is the case, abandon the preemption.
+        bool preempted = false;
+        if(thrd->link.next == 0p) {
+                preempted = true;
+                thrd->preempted = reason;
+                returnToKernel();
+        }
+        /* paranoid */ verify( ! __preemption_enabled() );
+        enable_interrupts_noPoll();
+        /* paranoid */ verify( __preemption_enabled() );
+        __disable_interrupts_checked();
+                $thread * thrd = kernelTLS().this_thread;
+                /* paranoid */ verify(thrd->state == Active);
+                // SKULLDUGGERY: It is possible that we are preempting this thread just before
+                // it was going to park itself. If that is the case and it is already using the
+                // intrusive fields then we can't use them to preempt the thread
+                // If that is the case, abandon the preemption.
+                bool preempted = false;
+                if(thrd->link.next == 0p) {
+                        preempted = true;
+                        thrd->preempted = reason;
+                        returnToKernel();
+                }
+        __enable_interrupts_checked( false );
         return preempted;
+}
 …
         unsigned idle;
         unsigned total;
         [idle, total, p] = query(this->idles);
+        [idle, total, p] = query_idles(this->procs);
         // If no one is sleeping, we are done
 …
         // We found a processor, wake it up
+        post( p->idle );
+        eventfd_t val;
+        val = 1;
+        eventfd_write( p->idle, val );
         #if !defined(__CFA_NO_STATISTICS__)
+                __tls_stats()->ready.sleep.wakes++;
+                if( kernelTLS().this_stats ) {
+                        __tls_stats()->ready.sleep.wakes++;
+                }
+                else {
+                        __atomic_fetch_add(&this->stats->ready.sleep.wakes, 1, __ATOMIC_RELAXED);
+                }
         #endif
 …
         __cfadbg_print_safe(runtime_core, "Kernel : waking Processor %p\n", this);
         disable_interrupts();
+        __disable_interrupts_checked();
                 /* paranoid */ verify( ! __preemption_enabled() );
+                post( this->idle );
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+static void push  (__cluster_idles & this, processor & proc) {
+                eventfd_t val;
+                val = 1;
+                eventfd_write( this->idle, val );
+        __enable_interrupts_checked();
+}
+static void mark_idle(__cluster_proc_list & this, processor & proc) {
         /* paranoid */ verify( ! __preemption_enabled() );
         lock( this );
                 this.idle++;
                 /* paranoid */ verify( this.idle <= this.total );
                 insert_first(this.list, proc);
+                remove(proc);
+                insert_first(this.idles, proc);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
+}
 static void remove(__cluster_idles & this, processor & proc) {
+static void mark_awake(__cluster_proc_list & this, processor & proc) {
         /* paranoid */ verify( ! __preemption_enabled() );
         lock( this );
                 this.idle--;
                 /* paranoid */ verify( this.idle >= 0 );
                 remove(proc);
+                insert_last(this.actives, proc);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
+}
+static [unsigned idle, unsigned total, * processor] query( & __cluster_idles this ) {
+static [unsigned idle, unsigned total, * processor] query_idles( & __cluster_proc_list this ) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        /* paranoid */ verify( ready_schedule_islocked() );
         for() {
                 uint64_t l = __atomic_load_n(&this.lock, __ATOMIC_SEQ_CST);
 …
                 unsigned idle    = this.idle;
                 unsigned total   = this.total;
                 processor * proc = &this.list`first;
+                processor * proc = &this.idles`first;
                 // Compiler fence is unnecessary, but gcc-8 and older incorrectly reorder code without it
                 asm volatile("": : :"memory");
 …
                 return [idle, total, proc];
+        }
+        /* paranoid */ verify( ready_schedule_islocked() );
+        /* paranoid */ verify( ! __preemption_enabled() );
+}
 …
 // Kernel Utilities
 //=============================================================================================
+#if defined(CFA_HAVE_LINUX_IO_URING_H)
+#include "io/types.hfa"
+#endif
+static inline bool __maybe_io_drain( processor * proc ) {
+        bool ret = false;
+        #if defined(CFA_HAVE_LINUX_IO_URING_H)
+                __cfadbg_print_safe(runtime_core, "Kernel : core %p checking io for ring %d\n", proc, proc->io.ctx->fd);
+                // Check if we should drain the queue
+                $io_context * ctx = proc->io.ctx;
+                unsigned head = *ctx->cq.head;
+                unsigned tail = *ctx->cq.tail;
+                if(head == tail) return false;
+                ready_schedule_lock();
+                ret = __cfa_io_drain( proc );
+                ready_schedule_unlock();
+        #endif
+        return ret;
+}
 //-----------------------------------------------------------------------------
 // Debug
 …
                 __print_stats( this.stats, this.print_stats, "Cluster", this.name, (void*)&this );
+        }
-        extern int __print_alarm_stats;
-        void print_alarm_stats() {
-                __print_alarm_stats = -1;
+        }
 #endif
 // Local Variables: //

libcfa/src/concurrency/kernel.hfa

-              rfeacef9
+              r5407cdc
+}
-//-----------------------------------------------------------------------------
-// Underlying Locks
 #ifdef __CFA_WITH_VERIFY__
         extern bool __cfaabi_dbg_in_kernel();
 #endif
+extern "C" {
+        char * strerror(int);
+}
+#define CHECKED(x) { int err = x; if( err != 0 ) abort("KERNEL ERROR: Operation \"" #x "\" return error %d - %s\n", err, strerror(err)); }
+struct __bin_sem_t {
+        pthread_mutex_t         lock;
+        pthread_cond_t          cond;
+        int                     val;
+};
+static inline void ?{}(__bin_sem_t & this) with( this ) {
+        // Create the mutex with error checking
+        pthread_mutexattr_t mattr;
+        pthread_mutexattr_init( &mattr );
+        pthread_mutexattr_settype( &mattr, PTHREAD_MUTEX_ERRORCHECK_NP);
+        pthread_mutex_init(&lock, &mattr);
+        pthread_cond_init (&cond, (const pthread_condattr_t *)0p);  // workaround trac#208: cast should not be required
+        val = 0;
+}
+static inline void ^?{}(__bin_sem_t & this) with( this ) {
+        CHECKED( pthread_mutex_destroy(&lock) );
+        CHECKED( pthread_cond_destroy (&cond) );
+}
+static inline void wait(__bin_sem_t & this) with( this ) {
+        verify(__cfaabi_dbg_in_kernel());
+        CHECKED( pthread_mutex_lock(&lock) );
+                while(val < 1) {
+                        pthread_cond_wait(&cond, &lock);
+                }
+                val -= 1;
+        CHECKED( pthread_mutex_unlock(&lock) );
+}
+static inline bool post(__bin_sem_t & this) with( this ) {
+        bool needs_signal = false;
+        CHECKED( pthread_mutex_lock(&lock) );
+                if(val < 1) {
+                        val += 1;
+                        pthread_cond_signal(&cond);
+                        needs_signal = true;
+                }
+        CHECKED( pthread_mutex_unlock(&lock) );
+        return needs_signal;
+}
+#undef CHECKED
+//-----------------------------------------------------------------------------
+// I/O
+struct cluster;
+struct $io_context;
+struct $io_arbiter;
+struct io_context_params {
+        int num_entries;
+};
+void  ?{}(io_context_params & this);
 //-----------------------------------------------------------------------------
 …
 struct __processor_id_t {
         unsigned id:24;
-        bool full_proc:1;
         #if !defined(__CFA_NO_STATISTICS__)
 …
         struct cluster * cltr;
+        // Ready Queue state per processor
+        struct {
+                unsigned short its;
+                unsigned short itr;
+                unsigned id;
+                unsigned target;
+                unsigned long long int cutoff;
+        } rdq;
         // Set to true to notify the processor should terminate
         volatile bool do_terminate;
 …
         // Handle to pthreads
         pthread_t kernel_thread;
+        struct {
+                $io_context * ctx;
+                bool pending;
+                bool dirty;
+        } io;
         // Preemption data
 …
         // Idle lock (kernel semaphore)
         __bin_sem_t idle;
+        int idle;
         // Termination synchronisation (user semaphore)
 …
         // Link lists fields
         DLISTED_MGD_IMPL_IN(processor)
+        // special init fields
+        // This is needed for memcached integration
+        // once memcached experiments are done this should probably be removed
+        // it is not a particularly safe scheme as it can make processors less homogeneous
+        struct {
+                $thread * thrd;
+        } init;
         #if !defined(__CFA_NO_STATISTICS__)
 …
 void ^?{}(processor & this);
 static inline void  ?{}(processor & this)                    { this{ "Anonymous Processor", *mainCluster}; }
 static inline void  ?{}(processor & this, struct cluster & cltr)    { this{ "Anonymous Processor", cltr}; }
 static inline void  ?{}(processor & this, const char name[]) { this{name, *mainCluster }; }
+static inline void  ?{}(processor & this)                        { this{ "Anonymous Processor", *mainCluster}; }
+static inline void  ?{}(processor & this, struct cluster & cltr) { this{ "Anonymous Processor", cltr}; }
+static inline void  ?{}(processor & this, const char name[])     { this{name, *mainCluster}; }
 DLISTED_MGD_IMPL_OUT(processor)
 //-----------------------------------------------------------------------------
-// I/O
-struct __io_data;
-// IO poller user-thread
-// Not using the "thread" keyword because we want to control
-// more carefully when to start/stop it
-struct $io_ctx_thread {
-        struct __io_data * ring;
-        single_sem sem;
-        volatile bool done;
-        $thread self;
-};
-struct io_context {
-        $io_ctx_thread thrd;
-};
-struct io_context_params {
-        int num_entries;
-        int num_ready;
-        int submit_aff;
-        bool eager_submits:1;
-        bool poller_submits:1;
-        bool poll_submit:1;
-        bool poll_complete:1;
-};
-void  ?{}(io_context_params & this);
-void  ?{}(io_context & this, struct cluster & cl);
-void  ?{}(io_context & this, struct cluster & cl, const io_context_params & params);
-void ^?{}(io_context & this);
-struct io_cancellation {
-        __u64 target;
-};
-static inline void  ?{}(io_cancellation & this) { this.target = -1u; }
-static inline void ^?{}(io_cancellation &) {}
-bool cancel(io_cancellation & this);
-//-----------------------------------------------------------------------------
 // Cluster Tools
 // Intrusives lanes which are used by the relaxed ready queue
+// Intrusives lanes which are used by the ready queue
 struct __attribute__((aligned(128))) __intrusive_lane_t;
 void  ?{}(__intrusive_lane_t & this);
 void ^?{}(__intrusive_lane_t & this);
+// Counter used for wether or not the lanes are all empty
+struct __attribute__((aligned(128))) __snzi_node_t;
+struct __snzi_t {
+        unsigned mask;
+        int root;
+        __snzi_node_t * nodes;
+};
+void  ?{}( __snzi_t & this, unsigned depth );
+void ^?{}( __snzi_t & this );
+// Aligned timestamps which are used by the relaxed ready queue
+struct __attribute__((aligned(128))) __timestamp_t;
+void  ?{}(__timestamp_t & this);
+void ^?{}(__timestamp_t & this);
 //TODO adjust cache size to ARCHITECTURE
 // Structure holding the relaxed ready queue
 struct __ready_queue_t {
-        // Data tracking how many/which lanes are used
-        // Aligned to 128 for cache locality
-        __snzi_t snzi;
         // Data tracking the actual lanes
         // On a seperate cacheline from the used struct since
 …
                 __intrusive_lane_t * volatile data;
+                // Array of times
+                __timestamp_t * volatile tscs;
                 // Number of lanes (empty or not)
                 volatile size_t count;
 …
 // Idle Sleep
 struct __cluster_idles {
+struct __cluster_proc_list {
         // Spin lock protecting the queue
         volatile uint64_t lock;
 …
         // List of idle processors
+        dlist(processor, processor) list;
+        dlist(processor, processor) idles;
+        // List of active processors
+        dlist(processor, processor) actives;
 };
 …
         // List of idle processors
         __cluster_idles idles;
+        __cluster_proc_list procs;
         // List of threads
 …
         struct {
                 io_context * ctxs;
                 unsigned cnt;
+                $io_arbiter * arbiter;
+                io_context_params params;
         } io;

libcfa/src/concurrency/kernel/fwd.hfa

-              rfeacef9
+              r5407cdc
         extern void disable_interrupts();
+        extern void enable_interrupts_noPoll();
+        extern void enable_interrupts( __cfaabi_dbg_ctx_param );
+        extern void enable_interrupts( bool poll = false );
         extern "Cforall" {
 …
                         // Mark as fulfilled, wake thread if needed
                         // return true if a thread was unparked
                         bool post(oneshot & this) {
+                        $thread * post(oneshot & this, bool do_unpark = true) {
                                 struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
                                 if( got == 0p ) return false;
                                 unpark( got );
                                 return true;
+                                if( got == 0p ) return 0p;
+                                if(do_unpark) unpark( got );
+                                return got;
+                        }
+                }
 …
                         // from the server side, mark the future as fulfilled
                         // delete it if needed
                         bool fulfil( future_t & this ) {
+                        $thread * fulfil( future_t & this, bool do_unpark = true  ) {
                                 for() {
                                         struct oneshot * expected = this.ptr;
 …
                                                 #pragma GCC diagnostic ignored "-Wfree-nonheap-object"
                                         #endif
                                                 if( expected == 3p ) { free( &this ); return false; }
+                                                if( expected == 3p ) { free( &this ); return 0p; }
                                         #if defined(__GNUC__) && __GNUC__ >= 7
                                                 #pragma GCC diagnostic pop
 …
                                         struct oneshot * want = expected == 0p ? 1p : 2p;
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, want, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                                 if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return false; }
                                                 bool ret = post( *expected );
+                                                if( expected == 0p ) { /* paranoid */ verify( this.ptr == 1p); return 0p; }
+                                                $thread * ret = post( *expected, do_unpark );
                                                 __atomic_store_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
                                                 return ret;
 …
                                         __VA_ARGS__ \
                                 } \
                                 if( !(in_kernel) ) enable_interrupts( __cfaabi_dbg_ctx ); \
+                                if( !(in_kernel) ) enable_interrupts(); \
+                        }
                 #else

libcfa/src/concurrency/kernel/startup.cfa

-              rfeacef9
+              r5407cdc
 extern "C" {
       #include <limits.h>       // PTHREAD_STACK_MIN
+        #include <sys/eventfd.h>  // eventfd
       #include <sys/mman.h>     // mprotect
       #include <sys/resource.h> // getrlimit
 …
 static void __kernel_first_resume( processor * this );
 static void __kernel_last_resume ( processor * this );
 static void init(processor & this, const char name[], cluster & _cltr);
+static void init(processor & this, const char name[], cluster & _cltr, $thread * initT);
 static void deinit(processor & this);
 static void doregister( struct cluster & cltr );
 …
 extern void __kernel_alarm_startup(void);
 extern void __kernel_alarm_shutdown(void);
-extern void __kernel_io_startup (void);
-extern void __kernel_io_shutdown(void);
 //-----------------------------------------------------------------------------
 …
 KERNEL_STORAGE($thread,              mainThread);
 KERNEL_STORAGE(__stack_t,            mainThreadCtx);
-KERNEL_STORAGE(io_context,           mainPollerThread);
 KERNEL_STORAGE(__scheduler_RWLock_t, __scheduler_lock);
 #if !defined(__CFA_NO_STATISTICS__)
 …
         void ?{}(processor & this) with( this ) {
-                ( this.idle ){};
                 ( this.terminated ){};
                 ( this.runner ){};
                 init( this, "Main Processor", *mainCluster );
+                init( this, "Main Processor", *mainCluster, 0p );
                 kernel_thread = pthread_self();
 …
         __kernel_alarm_startup();
-        // Start IO
-        __kernel_io_startup();
         // 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(mainThread);
+        schedule_thread$(mainThread);
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
 …
         // THE SYSTEM IS NOW COMPLETELY RUNNING
-        // SKULLDUGGERY: The constructor for the mainCluster will call alloc with a dimension of 0
-        // malloc *can* return a non-null value, we should free it if that is the case
-        free( mainCluster->io.ctxs );
-        // Now that the system is up, finish creating systems that need threading
-        mainCluster->io.ctxs = (io_context *)&storage_mainPollerThread;
-        mainCluster->io.cnt  = 1;
-        (*mainCluster->io.ctxs){ *mainCluster };
         __cfadbg_print_safe(runtime_core, "Kernel : Started\n--------------------------------------------------\n\n");
         /* paranoid */ verify( ! __preemption_enabled() );
         enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
         /* paranoid */ verify( __preemption_enabled() );
 …
 static void __kernel_shutdown(void) {
-        //Before we start shutting things down, wait for systems that need threading to shutdown
-        ^(*mainCluster->io.ctxs){};
-        mainCluster->io.cnt  = 0;
-        mainCluster->io.ctxs = 0p;
         /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();
 …
         __kernel_alarm_shutdown();
+        // Stop IO
+        __kernel_io_shutdown();
+        #if !defined( __CFA_NO_STATISTICS__ )
+                __stats_t * st = (__stats_t *)& storage_mainProcStats;
+                __tally_stats(mainCluster->stats, st);
+                if( 0 != mainProcessor->print_stats ) {
+                        __print_stats( st, mainProcessor->print_stats, "Processor ", mainProcessor->name, (void*)mainProcessor );
+                }
+                #if defined(CFA_STATS_ARRAY)
+                        __flush_stat( st, "Processor", mainProcessor );
+                #endif
+        #endif
         // Destroy the main processor and its context in reverse order of construction
 …
                         __print_stats( &local_stats, proc->print_stats, "Processor ", proc->name, (void*)proc );
+                }
+                #if defined(CFA_STATS_ARRAY)
+                        __flush_stat( &local_stats, "Processor", proc );
+                #endif
         #endif
 …
         link.next = 0p;
         link.prev = 0p;
+        link.preferred = -1u;
+        last_proc = 0p;
         #if defined( __CFA_WITH_VERIFY__ )
                 canary = 0x0D15EA5E0D15EA5Ep;
 …
+}
 static void init(processor & this, const char name[], cluster & _cltr) with( this ) {
+static void init(processor & this, const char name[], cluster & _cltr, $thread * initT) with( this ) {
         this.name = name;
         this.cltr = &_cltr;
+        full_proc = true;
+        this.rdq.its = 0;
+        this.rdq.itr = 0;
+        this.rdq.id  = -1u;
+        this.rdq.target = -1u;
+        this.rdq.cutoff = -1ull;
         do_terminate = false;
         preemption_alarm = 0p;
         pending_preemption = false;
+        this.io.ctx = 0p;
+        this.io.pending = false;
+        this.io.dirty   = false;
+        this.init.thrd = initT;
+        this.idle = eventfd(0, 0);
+        if (idle < 0) {
+                abort("KERNEL ERROR: PROCESSOR EVENTFD - %s\n", strerror(errno));
+        }
         #if !defined(__CFA_NO_STATISTICS__)
                 print_stats = 0;
 …
         #endif
+        lock( this.cltr->idles );
+                int target = this.cltr->idles.total += 1u;
+        unlock( this.cltr->idles );
+        id = doregister((__processor_id_t*)&this);
+        // Register and Lock the RWlock so no-one pushes/pops while we are changing the queue
+        uint_fast32_t last_size = ready_mutate_register((__processor_id_t*)&this);
+                this.cltr->procs.total += 1u;
+                insert_last(this.cltr->procs.actives, this);
+                // Adjust the ready queue size
+                ready_queue_grow( cltr );
+        // Unlock the RWlock
+        ready_mutate_unlock( last_size );
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
+}
+// Not a ctor, it just preps the destruction but should not destroy members
+static void deinit(processor & this) {
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
         uint_fast32_t last_size = ready_mutate_lock();
+                this.cltr->procs.total -= 1u;
+                remove(this);
                 // Adjust the ready queue size
+                ready_queue_grow( cltr, target );
+        // Unlock the RWlock
+        ready_mutate_unlock( last_size );
+        __cfadbg_print_safe(runtime_core, "Kernel : core %p created\n", &this);
+}
+// Not a ctor, it just preps the destruction but should not destroy members
+static void deinit(processor & this) {
+        lock( this.cltr->idles );
+                int target = this.cltr->idles.total -= 1u;
+        unlock( this.cltr->idles );
+        // Lock the RWlock so no-one pushes/pops while we are changing the queue
+        uint_fast32_t last_size = ready_mutate_lock();
+                // Adjust the ready queue size
+                ready_queue_shrink( this.cltr, target );
+        // Unlock the RWlock
+        ready_mutate_unlock( last_size );
+        // Finally we don't need the read_lock any more
+        unregister((__processor_id_t*)&this);
+}
+void ?{}(processor & this, const char name[], cluster & _cltr) {
+        ( this.idle ){};
+                ready_queue_shrink( this.cltr );
+        // Unlock the RWlock and unregister: we don't need the read_lock any more
+        ready_mutate_unregister((__processor_id_t*)&this, last_size );
+        close(this.idle);
+}
+void ?{}(processor & this, const char name[], cluster & _cltr, $thread * initT) {
         ( this.terminated ){};
         ( this.runner ){};
         disable_interrupts();
                 init( this, name, _cltr );
         enable_interrupts( __cfaabi_dbg_ctx );
+                init( this, name, _cltr, initT );
+        enable_interrupts();
         __cfadbg_print_safe(runtime_core, "Kernel : Starting core %p\n", &this);
         this.stack = __create_pthread( &this.kernel_thread, __invoke_processor, (void *)&this );
+}
+void ?{}(processor & this, const char name[], cluster & _cltr) {
+        (this){name, _cltr, 0p};
+}
 …
         disable_interrupts();
                 deinit( this );
         enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
+}
 //-----------------------------------------------------------------------------
 // Cluster
 static void ?{}(__cluster_idles & this) {
+static void ?{}(__cluster_proc_list & this) {
         this.lock  = 0;
         this.idle  = 0;
         this.total = 0;
-        (this.list){};
+}
 …
         threads{ __get };
+        io.arbiter = create();
+        io.params = io_params;
         doregister(this);
 …
                 // Adjust the ready queue size
                 ready_queue_grow( &this, 0 );
+                ready_queue_grow( &this );
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
+        enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+        this.io.cnt  = num_io;
+        this.io.ctxs = aalloc(num_io);
+        for(i; this.io.cnt) {
+                (this.io.ctxs[i]){ this, io_params };
+        }
+        enable_interrupts( false ); // Don't poll, could be in main cluster
+}
 void ^?{}(cluster & this) {
+        for(i; this.io.cnt) {
+                ^(this.io.ctxs[i]){ true };
+        }
+        free(this.io.ctxs);
+        destroy(this.io.arbiter);
         // Lock the RWlock so no-one pushes/pops while we are changing the queue
 …
                 // Adjust the ready queue size
                 ready_queue_shrink( &this, 0 );
+                ready_queue_shrink( &this );
         // Unlock the RWlock
         ready_mutate_unlock( last_size );
         enable_interrupts_noPoll(); // Don't poll, could be in main cluster
+        enable_interrupts( false ); // Don't poll, could be in main cluster
         #if !defined(__CFA_NO_STATISTICS__)
 …
                         __print_stats( this.stats, this.print_stats, "Cluster", this.name, (void*)&this );
+                }
+                #if defined(CFA_STATS_ARRAY)
+                        __flush_stat( this.stats, "Cluster", &this );
+                #endif
                 free( this.stats );
         #endif
 …
+}
 #if defined(__CFA_WITH_VERIFY__)
 static bool verify_fwd_bck_rng(void) {

libcfa/src/concurrency/kernel_private.hfa

-              rfeacef9
+              r5407cdc
 extern "C" {
         void disable_interrupts() OPTIONAL_THREAD;
+        void enable_interrupts_noPoll();
+        void enable_interrupts( __cfaabi_dbg_ctx_param );
+}
+void __schedule_thread( $thread * )
+#if defined(NDEBUG) || (!defined(__CFA_DEBUG__) && !defined(__CFA_VERIFY__))
+        __attribute__((nonnull (1)))
+#endif
+;
+        void enable_interrupts( bool poll = true );
+}
+void schedule_thread$( $thread * ) __attribute__((nonnull (1)));
 extern bool __preemption_enabled();
 …
 //-----------------------------------------------------------------------------
 // I/O
+void ^?{}(io_context & this, bool );
+$io_arbiter * create(void);
+void destroy($io_arbiter *);
 //=======================================================================
 // Cluster lock API
 //=======================================================================
-// Cells use by the reader writer lock
-// while not generic it only relies on a opaque pointer
-struct __attribute__((aligned(128))) __scheduler_lock_id_t {
-        // Spin lock used as the underlying lock
-        volatile bool lock;
-        // Handle pointing to the proc owning this cell
-        // Used for allocating cells and debugging
-        __processor_id_t * volatile handle;
-        #ifdef __CFA_WITH_VERIFY__
-                // Debug, check if this is owned for reading
-                bool owned;
-        #endif
-};
-static_assert( sizeof(struct __scheduler_lock_id_t) <= __alignof(struct __scheduler_lock_id_t));
 // Lock-Free registering/unregistering of threads
 // Register a processor to a given cluster and get its unique id in return
 unsigned doregister( struct __processor_id_t * proc );
+void register_proc_id( struct __processor_id_t * );
 // Unregister a processor from a given cluster using its id, getting back the original pointer
+void     unregister( struct __processor_id_t * proc );
+//-----------------------------------------------------------------------
+// Cluster idle lock/unlock
+static inline void lock(__cluster_idles & this) {
+        for() {
+                uint64_t l = this.lock;
+                if(
+                        (0 == (l % 2))
+                        && __atomic_compare_exchange_n(&this.lock, &l, l + 1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+                ) return;
+                Pause();
+        }
+}
+static inline void unlock(__cluster_idles & this) {
+        /* paranoid */ verify( 1 == (this.lock % 2) );
+        __atomic_fetch_add( &this.lock, 1, __ATOMIC_SEQ_CST );
+}
+void unregister_proc_id( struct __processor_id_t * proc );
 //=======================================================================
 …
         __atomic_store_n(ll, (bool)false, __ATOMIC_RELEASE);
+}
+// Cells use by the reader writer lock
+// while not generic it only relies on a opaque pointer
+struct __attribute__((aligned(128))) __scheduler_lock_id_t {
+        // Spin lock used as the underlying lock
+        volatile bool lock;
+        // Handle pointing to the proc owning this cell
+        // Used for allocating cells and debugging
+        __processor_id_t * volatile handle;
+        #ifdef __CFA_WITH_VERIFY__
+                // Debug, check if this is owned for reading
+                bool owned;
+        #endif
+};
+static_assert( sizeof(struct __scheduler_lock_id_t) <= __alignof(struct __scheduler_lock_id_t));
 //-----------------------------------------------------------------------
 …
 void ready_mutate_unlock( uint_fast32_t /* value returned by lock */ );
+//-----------------------------------------------------------------------
+// Lock-Free registering/unregistering of threads
+// Register a processor to a given cluster and get its unique id in return
+// For convenience, also acquires the lock
+static inline uint_fast32_t ready_mutate_register( struct __processor_id_t * proc ) {
+        register_proc_id( proc );
+        return ready_mutate_lock();
+}
+// Unregister a processor from a given cluster using its id, getting back the original pointer
+// assumes the lock is acquired
+static inline void ready_mutate_unregister( struct __processor_id_t * proc, uint_fast32_t last_s ) {
+        ready_mutate_unlock( last_s );
+        unregister_proc_id( proc );
+}
+//-----------------------------------------------------------------------
+// Cluster idle lock/unlock
+static inline void lock(__cluster_proc_list & this) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        // Start by locking the global RWlock so that we know no-one is
+        // adding/removing processors while we mess with the idle lock
+        ready_schedule_lock();
+        // Simple counting lock, acquired, acquired by incrementing the counter
+        // to an odd number
+        for() {
+                uint64_t l = this.lock;
+                if(
+                        (0 == (l % 2))
+                        && __atomic_compare_exchange_n(&this.lock, &l, l + 1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)
+                ) return;
+                Pause();
+        }
+        /* paranoid */ verify( ! __preemption_enabled() );
+}
+static inline void unlock(__cluster_proc_list & this) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        /* paranoid */ verify( 1 == (this.lock % 2) );
+        // Simple couting lock, release by incrementing to an even number
+        __atomic_fetch_add( &this.lock, 1, __ATOMIC_SEQ_CST );
+        // Release the global lock, which we acquired when locking
+        ready_schedule_unlock();
+        /* paranoid */ verify( ! __preemption_enabled() );
+}
 //=======================================================================
 // Ready-Queue API
 //-----------------------------------------------------------------------
-// pop thread from the ready queue of a cluster
-// returns 0p if empty
-__attribute__((hot)) bool query(struct cluster * cltr);
-//-----------------------------------------------------------------------
 // push thread onto a ready queue for a cluster
 // returns true if the list was previously empty, false otherwise
 __attribute__((hot)) bool push(struct cluster * cltr, struct $thread * thrd);
 //-----------------------------------------------------------------------
 // pop thread from the ready queue of a cluster
+__attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd);
+//-----------------------------------------------------------------------
+// pop thread from the local queues of a cluster
 // returns 0p if empty
 // May return 0p spuriously
+__attribute__((hot)) struct $thread * pop(struct cluster * cltr);
+//-----------------------------------------------------------------------
+// pop thread from the ready queue of a cluster
+__attribute__((hot)) struct $thread * pop_fast(struct cluster * cltr);
+//-----------------------------------------------------------------------
+// pop thread from any ready queue of a cluster
+// returns 0p if empty
+// May return 0p spuriously
+__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr);
+//-----------------------------------------------------------------------
+// search all ready queues of a cluster for any thread
 // returns 0p if empty
 // guaranteed to find any threads added before this call
+__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr);
+//-----------------------------------------------------------------------
+// remove thread from the ready queue of a cluster
+// returns bool if it wasn't found
+bool remove_head(struct cluster * cltr, struct $thread * thrd);
+__attribute__((hot)) struct $thread * pop_search(struct cluster * cltr);
 //-----------------------------------------------------------------------
 // Increase the width of the ready queue (number of lanes) by 4
 void ready_queue_grow  (struct cluster * cltr, int target);
+void ready_queue_grow  (struct cluster * cltr);
 //-----------------------------------------------------------------------
 // Decrease the width of the ready queue (number of lanes) by 4
 void ready_queue_shrink(struct cluster * cltr, int target);
+void ready_queue_shrink(struct cluster * cltr);

libcfa/src/concurrency/locks.cfa

-              rfeacef9
+              r5407cdc
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
+        /* paranoid */ verifyf( owner == active_thread() || !strict_owner, "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+        /* paranoid */ verifyf( owner == active_thread() || !strict_owner , "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+        /* paranoid */ verifyf( recursion_count == 1 || multi_acquisition, "Thread %p attempted to release owner lock %p which is not recursive but has a recursive count of %zu", active_thread(), &this, recursion_count );
         // if recursion count is zero release lock and set new owner if one is waiting
 …
 size_t wait_count( blocking_lock & this ) with( this ) {
         return wait_count;
+}
-void set_recursion_count( blocking_lock & this, size_t recursion ) with( this ) {
-        recursion_count = recursion;
+}
-size_t get_recursion_count( blocking_lock & this ) with( this ) {
-        return recursion_count;
+}
 …
+}
 void on_wait( blocking_lock & this ) with( this ) {
+size_t on_wait( blocking_lock & this ) with( this ) {
         lock( lock __cfaabi_dbg_ctx2 );
         /* paranoid */ verifyf( owner != 0p, "Attempt to release lock %p that isn't held", &this );
         /* paranoid */ verifyf( owner == active_thread() || !strict_owner, "Thread %p other than the owner %p attempted to release owner lock %p", owner, active_thread(), &this );
+        size_t ret = recursion_count;
         pop_and_set_new_owner( this );
         unlock( lock );
+        return ret;
+}
+void on_wakeup( blocking_lock & this, size_t recursion ) with( this ) {
+        recursion_count = recursion;
+}
 …
+        }
+        bool empty( condition_variable(L) & this ) with(this) { return empty(blocked_threads); }
+        bool empty( condition_variable(L) & this ) with(this) {
+                lock( lock __cfaabi_dbg_ctx2 );
+                bool ret = empty(blocked_threads);
+                unlock( lock );
+                return ret;
+        }
         int counter( condition_variable(L) & this ) with(this) { return count; }
 …
                 if (i->lock) {
                         // if lock was passed get recursion count to reset to after waking thread
+                        recursion_count = get_recursion_count(*i->lock);
+                        on_wait( *i->lock );
+                        recursion_count = on_wait( *i->lock );
+                }
                 return recursion_count;
 …
                 // resets recursion count here after waking
                 if (i.lock) set_recursion_count(*i.lock, recursion_count);
+                if (i.lock) on_wakeup(*i.lock, recursion_count);
+        }
 …
                 // resets recursion count here after waking
                 if (info.lock) set_recursion_count(*info.lock, recursion_count);
+                if (info.lock) on_wakeup(*info.lock, recursion_count);
+        }
 …
+}
 bool V(semaphore & this) with( this ) {
+$thread * V (semaphore & this, const bool doUnpark ) with( this ) {
         $thread * thrd = 0p;
         lock( lock __cfaabi_dbg_ctx2 );
 …
         // make new owner
+        unpark( thrd );
+        if( doUnpark ) unpark( thrd );
+        return thrd;
+}
+bool V(semaphore & this) with( this ) {
+        $thread * thrd = V(this, true);
         return thrd != 0p;
+}

libcfa/src/concurrency/locks.hfa

-              rfeacef9
+              r5407cdc
 #include "bits/weakso_locks.hfa"
+#include "containers/queueLockFree.hfa"
+#include "thread.hfa"
 #include "time_t.hfa"
 #include "time.hfa"
+//-----------------------------------------------------------------------------
+// Semaphores
+// '0-nary' semaphore
+// Similar to a counting semaphore except the value of one is never reached
+// as a consequence, a V() that would bring the value to 1 *spins* until
+// a P consumes it
+struct Semaphore0nary {
+        __spinlock_t lock; // needed to protect
+        mpsc_queue($thread) queue;
+};
+static inline bool P(Semaphore0nary & this, $thread * thrd) {
+        /* paranoid */ verify(!(thrd->seqable.next));
+        /* paranoid */ verify(!(thrd`next));
+        push(this.queue, thrd);
+        return true;
+}
+static inline bool P(Semaphore0nary & this) {
+    $thread * thrd = active_thread();
+    P(this, thrd);
+    park();
+    return true;
+}
+static inline $thread * V(Semaphore0nary & this, bool doUnpark = true) {
+        $thread * next;
+        lock(this.lock __cfaabi_dbg_ctx2);
+                for (;;) {
+                        next = pop(this.queue);
+                        if (next) break;
+                        Pause();
+                }
+        unlock(this.lock);
+        if (doUnpark) unpark(next);
+        return next;
+}
+// Wrapper used on top of any sempahore to avoid potential locking
+struct BinaryBenaphore {
+        volatile ssize_t counter;
+};
+static inline {
+        void ?{}(BinaryBenaphore & this) { this.counter = 0; }
+        void ?{}(BinaryBenaphore & this, zero_t) { this.counter = 0; }
+        void ?{}(BinaryBenaphore & this, one_t ) { this.counter = 1; }
+        // returns true if no blocking needed
+        bool P(BinaryBenaphore & this) {
+                return __atomic_fetch_sub(&this.counter, 1, __ATOMIC_SEQ_CST) > 0;
+        }
+        bool tryP(BinaryBenaphore & this) {
+                ssize_t c = this.counter;
+                return (c >= 1) && __atomic_compare_exchange_n(&this.counter, &c, c-1, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
+        }
+        // returns true if notify needed
+        bool V(BinaryBenaphore & this) {
+                ssize_t c = 0;
+                for () {
+                        if (__atomic_compare_exchange_n(&this.counter, &c, c+1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                if (c == 0) return true;
+                                /* paranoid */ verify(c < 0);
+                                return false;
+                        } else {
+                                if (c == 1) return true;
+                                /* paranoid */ verify(c < 1);
+                                Pause();
+                        }
+                }
+        }
+}
+// Binary Semaphore based on the BinaryBenaphore on top of the 0-nary Semaphore
+struct ThreadBenaphore {
+        BinaryBenaphore ben;
+        Semaphore0nary  sem;
+};
+static inline void ?{}(ThreadBenaphore & this) {}
+static inline void ?{}(ThreadBenaphore & this, zero_t) { (this.ben){ 0 }; }
+static inline void ?{}(ThreadBenaphore & this, one_t ) { (this.ben){ 1 }; }
+static inline bool P(ThreadBenaphore & this)              { return P(this.ben) ? false : P(this.sem); }
+static inline bool tryP(ThreadBenaphore & this)           { return tryP(this.ben); }
+static inline bool P(ThreadBenaphore & this, bool wait)   { return wait ? P(this) : tryP(this); }
+static inline $thread * V(ThreadBenaphore & this, bool doUnpark = true) {
+        if (V(this.ben)) return 0p;
+        return V(this.sem, doUnpark);
+}
+//-----------------------------------------------------------------------------
+// Semaphore
+struct semaphore {
+        __spinlock_t lock;
+        int count;
+        __queue_t($thread) waiting;
+};
+void  ?{}(semaphore & this, int count = 1);
+void ^?{}(semaphore & this);
+bool   P (semaphore & this);
+bool   V (semaphore & this);
+bool   V (semaphore & this, unsigned count);
+$thread * V (semaphore & this, bool );
 //----------
 …
 static inline void  ?{}( single_acquisition_lock & this ) {((blocking_lock &)this){ false, false };}
 static inline void ^?{}( single_acquisition_lock & this ) {}
 static inline void   lock      ( single_acquisition_lock & this ) { lock   ( (blocking_lock &)this ); }
 static inline void   unlock    ( single_acquisition_lock & this ) { unlock ( (blocking_lock &)this ); }
 static inline void   on_wait   ( single_acquisition_lock & this ) { on_wait( (blocking_lock &)this ); }
 static inline void   on_notify ( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
 static inline void   set_recursion_count( single_acquisition_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
 static inline size_t get_recursion_count( single_acquisition_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
+static inline void   lock     ( single_acquisition_lock & this ) { lock    ( (blocking_lock &)this ); }
+static inline bool   try_lock ( single_acquisition_lock & this ) { return try_lock( (blocking_lock &)this ); }
+static inline void   unlock   ( single_acquisition_lock & this ) { unlock  ( (blocking_lock &)this ); }
+static inline size_t on_wait  ( single_acquisition_lock & this ) { return on_wait ( (blocking_lock &)this ); }
+static inline void   on_wakeup( single_acquisition_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
+static inline void   on_notify( single_acquisition_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
 //----------
 …
 static inline void  ?{}( owner_lock & this ) {((blocking_lock &)this){ true, true };}
 static inline void ^?{}( owner_lock & this ) {}
+static inline void   lock     ( owner_lock & this ) { lock   ( (blocking_lock &)this ); }
+static inline void   unlock   ( owner_lock & this ) { unlock ( (blocking_lock &)this ); }
+static inline void   on_wait  ( owner_lock & this ) { on_wait( (blocking_lock &)this ); }
+static inline void   lock     ( owner_lock & this ) { lock    ( (blocking_lock &)this ); }
+static inline bool   try_lock ( owner_lock & this ) { return try_lock( (blocking_lock &)this ); }
+static inline void   unlock   ( owner_lock & this ) { unlock  ( (blocking_lock &)this ); }
+static inline size_t on_wait  ( owner_lock & this ) { return on_wait ( (blocking_lock &)this ); }
+static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
 static inline void   on_notify( owner_lock & this, struct $thread * t ) { on_notify( (blocking_lock &)this, t ); }
+static inline void   set_recursion_count( owner_lock & this, size_t recursion ) { set_recursion_count( (blocking_lock &)this, recursion ); }
+static inline size_t get_recursion_count( owner_lock & this ) { return get_recursion_count( (blocking_lock &)this ); }
+struct fast_lock {
+        $thread * volatile owner;
+        ThreadBenaphore sem;
+};
+static inline bool $try_lock(fast_lock & this, $thread * thrd) {
+    $thread * exp = 0p;
+    return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
+}
+static inline void lock( fast_lock & this ) __attribute__((artificial));
+static inline void lock( fast_lock & this ) {
+        $thread * thrd = active_thread();
+        /* paranoid */verify(thrd != this.owner);
+        for (;;) {
+                if ($try_lock(this, thrd)) return;
+                P(this.sem);
+        }
+}
+static inline bool try_lock( fast_lock & this ) __attribute__((artificial));
+static inline bool try_lock ( fast_lock & this ) {
+        $thread * thrd = active_thread();
+        /* paranoid */ verify(thrd != this.owner);
+        return $try_lock(this, thrd);
+}
+static inline $thread * unlock( fast_lock & this ) __attribute__((artificial));
+static inline $thread * unlock( fast_lock & this ) {
+        /* paranoid */ verify(active_thread() == this.owner);
+        // open 'owner' before unlocking anyone
+        // so new and unlocked threads don't park incorrectly.
+        // This may require additional fencing on ARM.
+        this.owner = 0p;
+        return V(this.sem);
+}
+static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; }
+static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); }
+static inline void on_notify( fast_lock &, struct $thread * t ) { unpark(t); }
+struct mcs_node {
+        mcs_node * volatile next;
+        single_sem sem;
+};
+static inline void ?{}(mcs_node & this) { this.next = 0p; }
+static inline mcs_node * volatile & ?`next ( mcs_node * node ) {
+        return node->next;
+}
+struct mcs_lock {
+        mcs_queue(mcs_node) queue;
+};
+static inline void lock(mcs_lock & l, mcs_node & n) {
+        if(push(l.queue, &n))
+                wait(n.sem);
+}
+static inline void unlock(mcs_lock & l, mcs_node & n) {
+        mcs_node * next = advance(l.queue, &n);
+        if(next) post(next->sem);
+}
 //-----------------------------------------------------------------------------
 …
         // For synchronization locks to use when releasing
+        void on_wait( L & );
+        // to get recursion count for cond lock to reset after waking
+        size_t get_recursion_count( L & );
+        size_t on_wait( L & );
         // to set recursion count after getting signalled;
         void set_recursion_count( L &, size_t recursion );
+        void on_wakeup( L &, size_t recursion );
 };
 …
         bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+}
-//-----------------------------------------------------------------------------
-// Semaphore
-struct semaphore {
-        __spinlock_t lock;
-        int count;
-        __queue_t($thread) waiting;
-};
-void  ?{}(semaphore & this, int count = 1);
-void ^?{}(semaphore & this);
-bool   P (semaphore & this);
-bool   V (semaphore & this);
-bool   V (semaphore & this, unsigned count);

libcfa/src/concurrency/monitor.hfa

rfeacef9	r5407cdc
61	61	static inline forall( T & \| sized(T) \| { void ^?{}( T & mutex ); } )
62	62	void delete( T * th ) {
63		^(*th){};
	63	if(th) ^(*th){};
64	64	free( th );
65	65	}

libcfa/src/concurrency/preemption.cfa

-              rfeacef9
+              r5407cdc
 #define __cforall_thread__
+// #define __CFA_DEBUG_PRINT_PREEMPTION__
 #include "preemption.hfa"
 …
 #include "kernel_private.hfa"
 #if !defined(__CFA_DEFAULT_PREEMPTION__)
 #define __CFA_DEFAULT_PREEMPTION__ 10`ms
 #endif
+Duration default_preemption() __attribute__((weak)) {
+        return __CFA_DEFAULT_PREEMPTION__;
+__attribute__((weak)) Duration default_preemption() {
+        const char * preempt_rate_s = getenv("CFA_DEFAULT_PREEMPTION");
+        if(!preempt_rate_s) {
+                __cfadbg_print_safe(preemption, "No CFA_DEFAULT_PREEMPTION in ENV\n");
+                return __CFA_DEFAULT_PREEMPTION__;
+        }
+        char * endptr = 0p;
+        long int preempt_rate_l = strtol(preempt_rate_s, &endptr, 10);
+        if(preempt_rate_l < 0 || preempt_rate_l > 65535) {
+                __cfadbg_print_safe(preemption, "CFA_DEFAULT_PREEMPTION out of range : %ld\n", preempt_rate_l);
+                return __CFA_DEFAULT_PREEMPTION__;
+        }
+        if('\0' != *endptr) {
+                __cfadbg_print_safe(preemption, "CFA_DEFAULT_PREEMPTION not a decimal number : %s\n", preempt_rate_s);
+                return __CFA_DEFAULT_PREEMPTION__;
+        }
+        return preempt_rate_l`ms;
+}
 …
         //Loop throught every thing expired
         while( node = get_expired( alarms, currtime ) ) {
                 // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" );
+                __cfadbg_print_buffer_decl( preemption, " KERNEL: preemption tick %lu\n", currtime.tn);
                 Duration period = node->period;
                 if( period == 0) {
 …
+                }
+                __cfadbg_print_buffer_local( preemption, " KERNEL: alarm ticking node %p.\n", node );
                 // Check if this is a kernel
                 if( node->type == Kernel ) {
 …
+                }
                 else if( node->type == User ) {
+                        __cfadbg_print_buffer_local( preemption, " KERNEL: alarm unparking %p.\n", node->thrd );
                         timeout( node->thrd );
+                }
 …
                 // Check if this is a periodic alarm
                 if( period > 0 ) {
                         // __cfaabi_dbg_print_buffer_local( " KERNEL: alarm period is %lu.\n", period.tv );
+                        __cfadbg_print_buffer_local( preemption, " KERNEL: alarm period is %lu.\n", period`ns );
                         node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
 …
         // If there are still alarms pending, reset the timer
         if( & (*alarms)`first ) {
-                __cfadbg_print_buffer_decl(preemption, " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
                 Duration delta = (*alarms)`first.alarm - currtime;
                 Duration capped = max(delta, 50`us);
-                // itimerval tim  = { caped };
-                // __cfaabi_dbg_print_buffer_local( "    Values are %lu, %lu, %lu %lu.\n", delta.tv, caped.tv, tim.it_value.tv_sec, tim.it_value.tv_usec);
                 __kernel_set_timer( capped );
+        }
 …
         // Enable interrupts by decrementing the counter
         // If counter reaches 0, execute any pending __cfactx_switch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
+        void enable_interrupts( bool poll ) {
                 // Cache the processor now since interrupts can start happening after the atomic store
                 processor   * proc = __cfaabi_tls.this_processor;
                 /* paranoid */ verify( proc );
+                /* paranoid */ verify( !poll || proc );
                 with( __cfaabi_tls.preemption_state ){
 …
                                 // Signal the compiler that a fence is needed but only for signal handlers
                                 __atomic_signal_fence(__ATOMIC_RELEASE);
                                 if( proc->pending_preemption ) {
+                                if( poll && proc->pending_preemption ) {
                                         proc->pending_preemption = false;
                                         force_yield( __POLL_PREEMPTION );
+                                }
+                        }
+                }
-                // For debugging purposes : keep track of the last person to enable the interrupts
-                __cfaabi_dbg_debug_do( proc->last_enable = caller; )
+        }
-        // Disable interrupts by incrementint the counter
-        // Don't execute any pending __cfactx_switch even if counter reaches 0
-        void enable_interrupts_noPoll() {
-                unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
-                __cfaabi_tls.preemption_state.disable_count -= 1;
-                // If this triggers someone is enabled already enabled interrupts
-                /* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
-                if( prev == 1 ) {
-                        #if GCC_VERSION > 50000
-                                static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
-                        #endif
-                        // Set enabled flag to true
-                        // should be atomic to avoid preemption in the middle of the operation.
-                        // use memory order RELAXED since there is no inter-thread on this variable requirements
-                        __atomic_store_n(&__cfaabi_tls.preemption_state.enabled, true, __ATOMIC_RELAXED);
-                        // Signal the compiler that a fence is needed but only for signal handlers
-                        __atomic_signal_fence(__ATOMIC_RELEASE);
+                }
+        }
 …
         // Setup proper signal handlers
         __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // __cfactx_switch handler
         __cfaabi_sigaction( SIGALRM, sigHandler_alarm    , SA_SIGINFO | SA_RESTART ); // debug handler
+        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO ); // __cfactx_switch handler
+        __cfaabi_sigaction( SIGALRM, sigHandler_alarm    , SA_SIGINFO ); // debug handler
         signal_block( SIGALRM );
 …
+}
-#if !defined(__CFA_NO_STATISTICS__)
-        int __print_alarm_stats = 0;
-#endif
 // Main of the alarm thread
 // Waits on SIGALRM and send SIGUSR1 to whom ever needs it
 static void * alarm_loop( __attribute__((unused)) void * args ) {
         __processor_id_t id;
+        id.full_proc = false;
+        id.id = doregister(&id);
+        register_proc_id(&id);
         __cfaabi_tls.this_proc_id = &id;
-        #if !defined(__CFA_NO_STATISTICS__)
-                struct __stats_t local_stats;
-                __cfaabi_tls.this_stats = &local_stats;
-                __init_stats( &local_stats );
-        #endif
         // Block sigalrms to control when they arrive
 …
 EXIT:
         __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
+        unregister(&id);
+        #if !defined(__CFA_NO_STATISTICS__)
+                if( 0 != __print_alarm_stats ) {
+                        __print_stats( &local_stats, __print_alarm_stats, "Alarm", "Thread", 0p );
+                }
+        #endif
+        register_proc_id(&id);
         return 0p;
+}

libcfa/src/concurrency/ready_queue.cfa

-              rfeacef9
+              r5407cdc
 // #define __CFA_DEBUG_PRINT_READY_QUEUE__
+// #define USE_SNZI
+// #define USE_MPSC
+#define USE_RELAXED_FIFO
+// #define USE_WORK_STEALING
 #include "bits/defs.hfa"
 …
 #include <unistd.h>
-#include "snzi.hfa"
 #include "ready_subqueue.hfa"
 static const size_t cache_line_size = 64;
+#if !defined(__CFA_NO_STATISTICS__)
+        #define __STATS(...) __VA_ARGS__
+#else
+        #define __STATS(...)
+#endif
 // No overriden function, no environment variable, no define
 …
 #endif
+#define BIAS 16
+#if   defined(USE_RELAXED_FIFO)
+        #define BIAS 4
+        #define READYQ_SHARD_FACTOR 4
+        #define SEQUENTIAL_SHARD 1
+#elif defined(USE_WORK_STEALING)
+        #define READYQ_SHARD_FACTOR 2
+        #define SEQUENTIAL_SHARD 2
+#else
+        #error no scheduling strategy selected
+#endif
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct $thread * search(struct cluster * cltr);
+static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred);
 // returns the maximum number of processors the RWLock support
 …
 //=======================================================================
 // Lock-Free registering/unregistering of threads
 unsigned doregister( struct __processor_id_t * proc ) with(*__scheduler_lock) {
+void register_proc_id( struct __processor_id_t * proc ) with(*__scheduler_lock) {
         __cfadbg_print_safe(ready_queue, "Kernel : Registering proc %p for RW-Lock\n", proc);
 …
                         /*paranoid*/ verify(0 == (__alignof__(data[i]) % cache_line_size));
                         /*paranoid*/ verify((((uintptr_t)&data[i]) % cache_line_size) == 0);
                         return i;
+                        proc->id = i;
+                }
+        }
 …
         /*paranoid*/ verify(__alignof__(data[n]) == (2 * cache_line_size));
         /*paranoid*/ verify((((uintptr_t)&data[n]) % cache_line_size) == 0);
         return n;
+}
 void unregister( struct __processor_id_t * proc ) with(*__scheduler_lock) {
+        proc->id = n;
+}
+void unregister_proc_id( struct __processor_id_t * proc ) with(*__scheduler_lock) {
         unsigned id = proc->id;
         /*paranoid*/ verify(id < ready);
 …
 //=======================================================================
 // Cforall Reqdy Queue used for scheduling
+// Cforall Ready Queue used for scheduling
 //=======================================================================
 void ?{}(__ready_queue_t & this) with (this) {
         lanes.data  = 0p;
+        lanes.tscs  = 0p;
         lanes.count = 0;
+}
 void ^?{}(__ready_queue_t & this) with (this) {
+        verify( 1 == lanes.count );
+        #ifdef USE_SNZI
+                verify( !query( snzi ) );
+        #endif
+        verify( SEQUENTIAL_SHARD == lanes.count );
         free(lanes.data);
+        free(lanes.tscs);
+}
 //-----------------------------------------------------------------------
+__attribute__((hot)) bool query(struct cluster * cltr) {
+        #ifdef USE_SNZI
+                return query(cltr->ready_queue.snzi);
+        #endif
+        return true;
+}
+static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred) {
+        unsigned i;
+        bool local;
+        #if defined(BIAS)
+#if defined(USE_RELAXED_FIFO)
+        //-----------------------------------------------------------------------
+        // get index from random number with or without bias towards queues
+        static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred) {
+                unsigned i;
+                bool local;
                 unsigned rlow  = r % BIAS;
                 unsigned rhigh = r / BIAS;
 …
                         // (BIAS - 1) out of BIAS chances
                         // Use perferred queues
                         i = preferred + (rhigh % 4);
+                        i = preferred + (rhigh % READYQ_SHARD_FACTOR);
                         local = true;
+                }
 …
                         local = false;
+                }
+        #else
+                i = r;
+                local = false;
+                return [i, local];
+        }
+        __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd) with (cltr->ready_queue) {
+                __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
+                const bool external = (!kernelTLS().this_processor) || (cltr != kernelTLS().this_processor->cltr);
+                /* paranoid */ verify(external || kernelTLS().this_processor->rdq.id < lanes.count );
+                // write timestamp
+                thrd->link.ts = rdtscl();
+                bool local;
+                int preferred = external ? -1 : kernelTLS().this_processor->rdq.id;
+                // Try to pick a lane and lock it
+                unsigned i;
+                do {
+                        // Pick the index of a lane
+                        unsigned r = __tls_rand_fwd();
+                        [i, local] = idx_from_r(r, preferred);
+                        i %= __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.attempt, 1, __ATOMIC_RELAXED);
+                                else if(local) __tls_stats()->ready.push.local.attempt++;
+                                else __tls_stats()->ready.push.share.attempt++;
+                        #endif
+                #if defined(USE_MPSC)
+                        // mpsc always succeeds
+                } while( false );
+                #else
+                        // If we can't lock it retry
+                } while( !__atomic_try_acquire( &lanes.data[i].lock ) );
+                #endif
+                // Actually push it
+                push(lanes.data[i], thrd);
+                #if !defined(USE_MPSC)
+                        // Unlock and return
+                        __atomic_unlock( &lanes.data[i].lock );
+                #endif
+                // Mark the current index in the tls rng instance as having an item
+                __tls_rand_advance_bck();
+                __cfadbg_print_safe(ready_queue, "Kernel : Pushed %p on cluster %p (idx: %u, mask %llu, first %d)\n", thrd, cltr, i, used.mask[0], lane_first);
+                // Update statistics
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.success, 1, __ATOMIC_RELAXED);
+                        else if(local) __tls_stats()->ready.push.local.success++;
+                        else __tls_stats()->ready.push.share.success++;
+                #endif
+        }
+        // Pop from the ready queue from a given cluster
+        __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+                /* paranoid */ verify( lanes.count > 0 );
+                /* paranoid */ verify( kernelTLS().this_processor );
+                /* paranoid */ verify( kernelTLS().this_processor->rdq.id < lanes.count );
+                unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
+                int preferred = kernelTLS().this_processor->rdq.id;
+                // As long as the list is not empty, try finding a lane that isn't empty and pop from it
+                for(25) {
+                        // Pick two lists at random
+                        unsigned ri = __tls_rand_bck();
+                        unsigned rj = __tls_rand_bck();
+                        unsigned i, j;
+                        __attribute__((unused)) bool locali, localj;
+                        [i, locali] = idx_from_r(ri, preferred);
+                        [j, localj] = idx_from_r(rj, preferred);
+                        i %= count;
+                        j %= count;
+                        // try popping from the 2 picked lists
+                        struct $thread * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help)));
+                        if(thrd) {
+                                return thrd;
+                        }
+                }
+                // All lanes where empty return 0p
+                return 0p;
+        }
+        __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) { return pop_fast(cltr); }
+        __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) {
+                return search(cltr);
+        }
+#endif
+#if defined(USE_WORK_STEALING)
+        __attribute__((hot)) void push(struct cluster * cltr, struct $thread * thrd) with (cltr->ready_queue) {
+                __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
+                const bool external = (!kernelTLS().this_processor) || (cltr != kernelTLS().this_processor->cltr);
+                /* paranoid */ verify(external || kernelTLS().this_processor->rdq.id < lanes.count );
+                // write timestamp
+                thrd->link.ts = rdtscl();
+                // Try to pick a lane and lock it
+                unsigned i;
+                do {
+                        #if !defined(__CFA_NO_STATISTICS__)
+                                if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.attempt, 1, __ATOMIC_RELAXED);
+                                else __tls_stats()->ready.push.local.attempt++;
+                        #endif
+                        if(unlikely(external)) {
+                                i = __tls_rand() % lanes.count;
+                        }
+                        else {
+                                processor * proc = kernelTLS().this_processor;
+                                unsigned r = proc->rdq.its++;
+                                i =  proc->rdq.id + (r % READYQ_SHARD_FACTOR);
+                        }
+                #if defined(USE_MPSC)
+                        // mpsc always succeeds
+                } while( false );
+                #else
+                        // If we can't lock it retry
+                } while( !__atomic_try_acquire( &lanes.data[i].lock ) );
+                #endif
+                // Actually push it
+                push(lanes.data[i], thrd);
+                #if !defined(USE_MPSC)
+                        // Unlock and return
+                        __atomic_unlock( &lanes.data[i].lock );
+                #endif
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.success, 1, __ATOMIC_RELAXED);
+                        else __tls_stats()->ready.push.local.success++;
+                #endif
+                __cfadbg_print_safe(ready_queue, "Kernel : Pushed %p on cluster %p (idx: %u, mask %llu, first %d)\n", thrd, cltr, i, used.mask[0], lane_first);
+        }
+        // Pop from the ready queue from a given cluster
+        __attribute__((hot)) $thread * pop_fast(struct cluster * cltr) with (cltr->ready_queue) {
+                /* paranoid */ verify( lanes.count > 0 );
+                /* paranoid */ verify( kernelTLS().this_processor );
+                /* paranoid */ verify( kernelTLS().this_processor->rdq.id < lanes.count );
+                processor * proc = kernelTLS().this_processor;
+                if(proc->rdq.target == -1u) {
+                        proc->rdq.target = __tls_rand() % lanes.count;
+                        unsigned it1  = proc->rdq.itr;
+                        unsigned it2  = proc->rdq.itr + 1;
+                        unsigned idx1 = proc->rdq.id + (it1 % READYQ_SHARD_FACTOR);
+                        unsigned idx2 = proc->rdq.id + (it2 % READYQ_SHARD_FACTOR);
+                        unsigned long long tsc1 = ts(lanes.data[idx1]);
+                        unsigned long long tsc2 = ts(lanes.data[idx2]);
+                        proc->rdq.cutoff = min(tsc1, tsc2);
+                        if(proc->rdq.cutoff == 0) proc->rdq.cutoff = -1ull;
+                }
+                else {
+                        unsigned target = proc->rdq.target;
+                        proc->rdq.target = -1u;
+                        if(lanes.tscs[target].tv < proc->rdq.cutoff) {
+                                $thread * t = try_pop(cltr, target __STATS(, __tls_stats()->ready.pop.help));
+                                if(t) return t;
+                        }
+                }
+                for(READYQ_SHARD_FACTOR) {
+                        unsigned i = proc->rdq.id + (--proc->rdq.itr % READYQ_SHARD_FACTOR);
+                        if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
+                }
+                return 0p;
+        }
+        __attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
+                unsigned i = __tls_rand() % lanes.count;
+                return try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal));
+        }
+        __attribute__((hot)) struct $thread * pop_search(struct cluster * cltr) with (cltr->ready_queue) {
+                return search(cltr);
+        }
+#endif
+//=======================================================================
+// Various Ready Queue utilities
+//=======================================================================
+// these function work the same or almost the same
+// whether they are using work-stealing or relaxed fifo scheduling
+//-----------------------------------------------------------------------
+// try to pop from a lane given by index w
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
+        __STATS( stats.attempt++; )
+        // Get relevant elements locally
+        __intrusive_lane_t & lane = lanes.data[w];
+        // If list looks empty retry
+        if( is_empty(lane) ) {
+                __STATS( stats.espec++; )
+                return 0p;
+        }
+        // If we can't get the lock retry
+        if( !__atomic_try_acquire(&lane.lock) ) {
+                __STATS( stats.elock++; )
+                return 0p;
+        }
+        // If list is empty, unlock and retry
+        if( is_empty(lane) ) {
+                __atomic_unlock(&lane.lock);
+                __STATS( stats.eempty++; )
+                return 0p;
+        }
+        // Actually pop the list
+        struct $thread * thrd;
+        thrd = pop(lane);
+        /* paranoid */ verify(thrd);
+        /* paranoid */ verify(lane.lock);
+        // Unlock and return
+        __atomic_unlock(&lane.lock);
+        // Update statistics
+        __STATS( stats.success++; )
+        #if defined(USE_WORK_STEALING)
+                lanes.tscs[w].tv = thrd->link.ts;
         #endif
+        return [i, local];
+        // return the popped thread
+        return thrd;
+}
 //-----------------------------------------------------------------------
+__attribute__((hot)) bool push(struct cluster * cltr, struct $thread * thrd) with (cltr->ready_queue) {
+        __cfadbg_print_safe(ready_queue, "Kernel : Pushing %p on cluster %p\n", thrd, cltr);
+        // write timestamp
+        thrd->link.ts = rdtscl();
+        __attribute__((unused)) bool local;
+        __attribute__((unused)) int preferred;
+        #if defined(BIAS)
+                preferred =
+                        //*
+                        kernelTLS().this_processor ? kernelTLS().this_processor->id * 4 : -1;
+                        /*/
+                        thrd->link.preferred * 4;
+                        //*/
+        #endif
+        // Try to pick a lane and lock it
+        unsigned i;
+        do {
+                // Pick the index of a lane
+                // unsigned r = __tls_rand();
+                unsigned r = __tls_rand_fwd();
+                [i, local] = idx_from_r(r, preferred);
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(local) {
+                                __tls_stats()->ready.pick.push.local++;
+                        }
+                #endif
+                i %= __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
+                #if !defined(__CFA_NO_STATISTICS__)
+                        __tls_stats()->ready.pick.push.attempt++;
+                #endif
+                // If we can't lock it retry
+        } while( !__atomic_try_acquire( &lanes.data[i].lock ) );
+        bool first = false;
+        // Actually push it
+        #ifdef USE_SNZI
+                bool lane_first =
+        #endif
+        push(lanes.data[i], thrd);
+        #ifdef USE_SNZI
+                // If this lane used to be empty we need to do more
+                if(lane_first) {
+                        // Check if the entire queue used to be empty
+                        first = !query(snzi);
+                        // Update the snzi
+                        arrive( snzi, i );
+                }
+        #endif
+        __tls_rand_advance_bck();
+        // Unlock and return
+        __atomic_unlock( &lanes.data[i].lock );
+        __cfadbg_print_safe(ready_queue, "Kernel : Pushed %p on cluster %p (idx: %u, mask %llu, first %d)\n", thrd, cltr, i, used.mask[0], lane_first);
+        // Update statistics
+        #if !defined(__CFA_NO_STATISTICS__)
+                #if defined(BIAS)
+                        if( local ) __tls_stats()->ready.pick.push.lsuccess++;
+                #endif
+                __tls_stats()->ready.pick.push.success++;
+        #endif
+        // return whether or not the list was empty before this push
+        return first;
+}
+static struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j);
+static struct $thread * try_pop(struct cluster * cltr, unsigned i);
+// Pop from the ready queue from a given cluster
+__attribute__((hot)) $thread * pop(struct cluster * cltr) with (cltr->ready_queue) {
+        /* paranoid */ verify( lanes.count > 0 );
+        unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
+        int preferred;
+        #if defined(BIAS)
+                // Don't bother trying locally too much
+                int local_tries = 8;
+                preferred = kernelTLS().this_processor->id * 4;
+        #endif
+        // As long as the list is not empty, try finding a lane that isn't empty and pop from it
+        #ifdef USE_SNZI
+                while( query(snzi) ) {
+        #else
+                for(25) {
+        #endif
+                // Pick two lists at random
+                // unsigned ri = __tls_rand();
+                // unsigned rj = __tls_rand();
+                unsigned ri = __tls_rand_bck();
+                unsigned rj = __tls_rand_bck();
+                unsigned i, j;
+                __attribute__((unused)) bool locali, localj;
+                [i, locali] = idx_from_r(ri, preferred);
+                [j, localj] = idx_from_r(rj, preferred);
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(locali) {
+                                __tls_stats()->ready.pick.pop.local++;
+                        }
+                        if(localj) {
+                                __tls_stats()->ready.pick.pop.local++;
+                        }
+                #endif
+                i %= count;
+                j %= count;
+                // try popping from the 2 picked lists
+                struct $thread * thrd = try_pop(cltr, i, j);
+                if(thrd) {
+                        #if defined(BIAS) && !defined(__CFA_NO_STATISTICS__)
+                                if( locali || localj ) __tls_stats()->ready.pick.pop.lsuccess++;
+                        #endif
+                        return thrd;
+                }
+        }
+        // All lanes where empty return 0p
+        return 0p;
+}
+__attribute__((hot)) struct $thread * pop_slow(struct cluster * cltr) with (cltr->ready_queue) {
+// try to pop from any lanes making sure you don't miss any threads push
+// before the start of the function
+static inline struct $thread * search(struct cluster * cltr) with (cltr->ready_queue) {
         /* paranoid */ verify( lanes.count > 0 );
         unsigned count = __atomic_load_n( &lanes.count, __ATOMIC_RELAXED );
 …
         for(i; count) {
                 unsigned idx = (offset + i) % count;
                 struct $thread * thrd = try_pop(cltr, idx);
+                struct $thread * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search));
                 if(thrd) {
                         return thrd;
 …
+}
 //-----------------------------------------------------------------------
+// Given 2 indexes, pick the list with the oldest push an try to pop from it
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j) with (cltr->ready_queue) {
+        #if !defined(__CFA_NO_STATISTICS__)
+                __tls_stats()->ready.pick.pop.attempt++;
+        #endif
+        // Pick the bet list
+        int w = i;
+        if( __builtin_expect(!is_empty(lanes.data[j]), true) ) {
+                w = (ts(lanes.data[i]) < ts(lanes.data[j])) ? i : j;
+        }
+        return try_pop(cltr, w);
+}
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned w) with (cltr->ready_queue) {
+        // Get relevant elements locally
+        __intrusive_lane_t & lane = lanes.data[w];
+        // If list looks empty retry
+        if( is_empty(lane) ) return 0p;
+        // If we can't get the lock retry
+        if( !__atomic_try_acquire(&lane.lock) ) return 0p;
+        // If list is empty, unlock and retry
+        if( is_empty(lane) ) {
+                __atomic_unlock(&lane.lock);
+                return 0p;
+        }
+        // Actually pop the list
+        struct $thread * thrd;
+        thrd = pop(lane);
+        /* paranoid */ verify(thrd);
+        /* paranoid */ verify(lane.lock);
+        #ifdef USE_SNZI
+                // If this was the last element in the lane
+                if(emptied) {
+                        depart( snzi, w );
+                }
+        #endif
+        // Unlock and return
+        __atomic_unlock(&lane.lock);
+        // Update statistics
+        #if !defined(__CFA_NO_STATISTICS__)
+                __tls_stats()->ready.pick.pop.success++;
+        #endif
+        // Update the thread bias
+        thrd->link.preferred = w / 4;
+        // return the popped thread
+        return thrd;
+}
+//-----------------------------------------------------------------------
+bool remove_head(struct cluster * cltr, struct $thread * thrd) with (cltr->ready_queue) {
+        for(i; lanes.count) {
+                __intrusive_lane_t & lane = lanes.data[i];
+                bool removed = false;
+                __atomic_acquire(&lane.lock);
+                        if(head(lane)->link.next == thrd) {
+                                $thread * pthrd;
+                                pthrd = pop(lane);
+                                /* paranoid */ verify( pthrd == thrd );
+                                removed = true;
+                                #ifdef USE_SNZI
+                                        if(emptied) {
+                                                depart( snzi, i );
+                                        }
+                                #endif
+                        }
+                __atomic_unlock(&lane.lock);
+                if( removed ) return true;
+        }
+        return false;
+}
+//-----------------------------------------------------------------------
+// Check that all the intrusive queues in the data structure are still consistent
 static void check( __ready_queue_t & q ) with (q) {
         #if defined(__CFA_WITH_VERIFY__)
+        #if defined(__CFA_WITH_VERIFY__) && !defined(USE_MPSC)
+                {
                         for( idx ; lanes.count ) {
 …
                                 assert(tail(sl)->link.prev->link.next == tail(sl) );
                                 if(sl.before.link.ts == 0l) {
+                                if(is_empty(sl)) {
                                         assert(tail(sl)->link.prev == head(sl));
                                         assert(head(sl)->link.next == tail(sl));
 …
+}
+//-----------------------------------------------------------------------
+// Given 2 indexes, pick the list with the oldest push an try to pop from it
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
+        // Pick the bet list
+        int w = i;
+        if( __builtin_expect(!is_empty(lanes.data[j]), true) ) {
+                w = (ts(lanes.data[i]) < ts(lanes.data[j])) ? i : j;
+        }
+        return try_pop(cltr, w __STATS(, stats));
+}
 // Call this function of the intrusive list was moved using memcpy
 // fixes the list so that the pointers back to anchors aren't left dangling
 static inline void fix(__intrusive_lane_t & ll) {
+        // if the list is not empty then follow he pointer and fix its reverse
+        if(!is_empty(ll)) {
+                head(ll)->link.next->link.prev = head(ll);
+                tail(ll)->link.prev->link.next = tail(ll);
+        }
+        // Otherwise just reset the list
+        else {
+                verify(tail(ll)->link.next == 0p);
+                tail(ll)->link.prev = head(ll);
+                head(ll)->link.next = tail(ll);
+                verify(head(ll)->link.prev == 0p);
+        }
+        #if !defined(USE_MPSC)
+                // if the list is not empty then follow he pointer and fix its reverse
+                if(!is_empty(ll)) {
+                        head(ll)->link.next->link.prev = head(ll);
+                        tail(ll)->link.prev->link.next = tail(ll);
+                }
+                // Otherwise just reset the list
+                else {
+                        verify(tail(ll)->link.next == 0p);
+                        tail(ll)->link.prev = head(ll);
+                        head(ll)->link.next = tail(ll);
+                        verify(head(ll)->link.prev == 0p);
+                }
+        #endif
+}
+static void assign_list(unsigned & value, dlist(processor, processor) & list, unsigned count) {
+        processor * it = &list`first;
+        for(unsigned i = 0; i < count; i++) {
+                /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
+                it->rdq.id = value;
+                it->rdq.target = -1u;
+                value += READYQ_SHARD_FACTOR;
+                it = &(*it)`next;
+        }
+}
+static void reassign_cltr_id(struct cluster * cltr) {
+        unsigned preferred = 0;
+        assign_list(preferred, cltr->procs.actives, cltr->procs.total - cltr->procs.idle);
+        assign_list(preferred, cltr->procs.idles  , cltr->procs.idle );
+}
+static void fix_times( struct cluster * cltr ) with( cltr->ready_queue ) {
+        #if defined(USE_WORK_STEALING)
+                lanes.tscs = alloc(lanes.count, lanes.tscs`realloc);
+                for(i; lanes.count) {
+                        lanes.tscs[i].tv = ts(lanes.data[i]);
+                }
+        #endif
+}
 // Grow the ready queue
+void ready_queue_grow  (struct cluster * cltr, int target) {
+void ready_queue_grow(struct cluster * cltr) {
+        size_t ncount;
+        int target = cltr->procs.total;
         /* paranoid */ verify( ready_mutate_islocked() );
         __cfadbg_print_safe(ready_queue, "Kernel : Growing ready queue\n");
 …
         // grow the ready queue
         with( cltr->ready_queue ) {
-                #ifdef USE_SNZI
-                        ^(snzi){};
-                #endif
                 // Find new count
                 // Make sure we always have atleast 1 list
+                size_t ncount = target >= 2 ? target * 4: 1;
+                if(target >= 2) {
+                        ncount = target * READYQ_SHARD_FACTOR;
+                } else {
+                        ncount = SEQUENTIAL_SHARD;
+                }
                 // Allocate new array (uses realloc and memcpies the data)
 …
                 // Update original
                 lanes.count = ncount;
+                #ifdef USE_SNZI
+                        // Re-create the snzi
+                        snzi{ log2( lanes.count / 8 ) };
+                        for( idx; (size_t)lanes.count ) {
+                                if( !is_empty(lanes.data[idx]) ) {
+                                        arrive(snzi, idx);
+                                }
+                        }
+                #endif
+        }
+        }
+        fix_times(cltr);
+        reassign_cltr_id(cltr);
         // Make sure that everything is consistent
 …
 // Shrink the ready queue
 void ready_queue_shrink(struct cluster * cltr, int target) {
+void ready_queue_shrink(struct cluster * cltr) {
         /* paranoid */ verify( ready_mutate_islocked() );
         __cfadbg_print_safe(ready_queue, "Kernel : Shrinking ready queue\n");
 …
         /* paranoid */ check( cltr->ready_queue );
+        int target = cltr->procs.total;
         with( cltr->ready_queue ) {
-                #ifdef USE_SNZI
-                        ^(snzi){};
-                #endif
                 // Remember old count
                 size_t ocount = lanes.count;
 …
                 // Find new count
                 // Make sure we always have atleast 1 list
                 lanes.count = target >= 2 ? target * 4: 1;
+                lanes.count = target >= 2 ? target * READYQ_SHARD_FACTOR: SEQUENTIAL_SHARD;
                 /* paranoid */ verify( ocount >= lanes.count );
                 /* paranoid */ verify( lanes.count == target * 4 || target < 2 );
+                /* paranoid */ verify( lanes.count == target * READYQ_SHARD_FACTOR || target < 2 );
                 // for printing count the number of displaced threads
 …
                         fix(lanes.data[idx]);
+                }
+                #ifdef USE_SNZI
+                        // Re-create the snzi
+                        snzi{ log2( lanes.count / 8 ) };
+                        for( idx; (size_t)lanes.count ) {
+                                if( !is_empty(lanes.data[idx]) ) {
+                                        arrive(snzi, idx);
+                                }
+                        }
+                #endif
+        }
+        }
+        fix_times(cltr);
+        reassign_cltr_id(cltr);
         // Make sure that everything is consistent

libcfa/src/concurrency/ready_subqueue.hfa

-              rfeacef9
+              r5407cdc
 #define __CFA_NO_SCHED_STATS__
+#include "containers/queueLockFree.hfa"
 // Intrusives lanes which are used by the relaxed ready queue
 struct __attribute__((aligned(128))) __intrusive_lane_t {
+        // anchor for the head and the tail of the queue
+        __attribute__((aligned(128))) struct __sentinel_t {
+                // Link lists fields
+                // instrusive link field for threads
+                // must be exactly as in $thread
+                __thread_desc_link link;
+        } before, after;
+        #if defined(USE_MPSC)
+                mpsc_queue($thread) queue;
+                __attribute__((aligned(128)))
+        #else
+                // anchor for the head and the tail of the queue
+                __attribute__((aligned(128))) struct __sentinel_t {
+                        // Link lists fields
+                        // instrusive link field for threads
+                        // must be exactly as in $thread
+                        __thread_desc_link link;
+                } before, after;
+        #endif
         // spin lock protecting the queue
 …
 // Get the head pointer (one before the first element) from the anchor
 static inline $thread * head(const __intrusive_lane_t & this) {
+        $thread * rhead = ($thread *)(
+                (uintptr_t)( &this.before ) - offsetof( $thread, link )
+        );
+        /* paranoid */ verify(rhead);
+        return rhead;
+        #if defined(USE_MPSC)
+                return this.queue.head;
+        #else
+                $thread * rhead = ($thread *)(
+                        (uintptr_t)( &this.before ) - offsetof( $thread, link )
+                );
+                /* paranoid */ verify(rhead);
+                return rhead;
+        #endif
+}
 // Get the tail pointer (one after the last element) from the anchor
 static inline $thread * tail(const __intrusive_lane_t & this) {
+        $thread * rtail = ($thread *)(
+                (uintptr_t)( &this.after ) - offsetof( $thread, link )
+        );
+        /* paranoid */ verify(rtail);
+        return rtail;
+        #if defined(USE_MPSC)
+                return this.queue.tail;
+        #else
+                $thread * rtail = ($thread *)(
+                        (uintptr_t)( &this.after ) - offsetof( $thread, link )
+                );
+                /* paranoid */ verify(rtail);
+                return rtail;
+        #endif
+}
 …
         this.lock = false;
+        this.before.link.prev = 0p;
+        this.before.link.next = tail(this);
+        this.before.link.ts   = 0;
+        this.after .link.prev = head(this);
+        this.after .link.next = 0p;
+        this.after .link.ts   = 0;
+        #if !defined(__CFA_NO_SCHED_STATS__)
+                this.stat.diff = 0;
+                this.stat.push = 0;
+                this.stat.pop  = 0;
+        #endif
+        // We add a boat-load of assertions here because the anchor code is very fragile
+        /* paranoid */ verify(((uintptr_t)( head(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.before));
+        /* paranoid */ verify(((uintptr_t)( tail(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.after ));
+        /* paranoid */ verify(head(this)->link.prev == 0p );
+        /* paranoid */ verify(head(this)->link.next == tail(this) );
+        /* paranoid */ verify(tail(this)->link.next == 0p );
+        /* paranoid */ verify(tail(this)->link.prev == head(this) );
+        /* paranoid */ verify(&head(this)->link.prev == &this.before.link.prev );
+        /* paranoid */ verify(&head(this)->link.next == &this.before.link.next );
+        /* paranoid */ verify(&tail(this)->link.prev == &this.after .link.prev );
+        /* paranoid */ verify(&tail(this)->link.next == &this.after .link.next );
+        /* paranoid */ verify(__alignof__(__intrusive_lane_t) == 128);
+        /* paranoid */ verify(__alignof__(this) == 128);
+        /* paranoid */ verifyf(((intptr_t)(&this) % 128) == 0, "Expected address to be aligned %p %% 128 == %zd", &this, ((intptr_t)(&this) % 128));
+        #if !defined(USE_MPSC)
+                this.before.link.prev = 0p;
+                this.before.link.next = tail(this);
+                this.before.link.ts   = 0;
+                this.after .link.prev = head(this);
+                this.after .link.next = 0p;
+                this.after .link.ts   = 0;
+                #if !defined(__CFA_NO_SCHED_STATS__)
+                        this.stat.diff = 0;
+                        this.stat.push = 0;
+                        this.stat.pop  = 0;
+                #endif
+                // We add a boat-load of assertions here because the anchor code is very fragile
+                /* paranoid */ verify(((uintptr_t)( head(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.before));
+                /* paranoid */ verify(((uintptr_t)( tail(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.after ));
+                /* paranoid */ verify(head(this)->link.prev == 0p );
+                /* paranoid */ verify(head(this)->link.next == tail(this) );
+                /* paranoid */ verify(tail(this)->link.next == 0p );
+                /* paranoid */ verify(tail(this)->link.prev == head(this) );
+                /* paranoid */ verify(&head(this)->link.prev == &this.before.link.prev );
+                /* paranoid */ verify(&head(this)->link.next == &this.before.link.next );
+                /* paranoid */ verify(&tail(this)->link.prev == &this.after .link.prev );
+                /* paranoid */ verify(&tail(this)->link.next == &this.after .link.next );
+                /* paranoid */ verify(__alignof__(__intrusive_lane_t) == 128);
+                /* paranoid */ verify(__alignof__(this) == 128);
+                /* paranoid */ verifyf(((intptr_t)(&this) % 128) == 0, "Expected address to be aligned %p %% 128 == %zd", &this, ((intptr_t)(&this) % 128));
+        #endif
+}
 // Dtor is trivial
 void ^?{}( __intrusive_lane_t & this ) {
+        // Make sure the list is empty
+        /* paranoid */ verify(head(this)->link.prev == 0p );
+        /* paranoid */ verify(head(this)->link.next == tail(this) );
+        /* paranoid */ verify(tail(this)->link.next == 0p );
+        /* paranoid */ verify(tail(this)->link.prev == head(this) );
+        #if !defined(USE_MPSC)
+                // Make sure the list is empty
+                /* paranoid */ verify(head(this)->link.prev == 0p );
+                /* paranoid */ verify(head(this)->link.next == tail(this) );
+                /* paranoid */ verify(tail(this)->link.next == 0p );
+                /* paranoid */ verify(tail(this)->link.prev == head(this) );
+        #endif
+}
 …
 // returns true of lane was empty before push, false otherwise
 bool push(__intrusive_lane_t & this, $thread * node) {
+        #if defined(__CFA_WITH_VERIFY__)
+                /* paranoid */ verify(this.lock);
+                /* paranoid */ verify(node->link.ts != 0);
+                /* paranoid */ verify(node->link.next == 0p);
+                /* paranoid */ verify(node->link.prev == 0p);
+                /* paranoid */ verify(tail(this)->link.next == 0p);
+                /* paranoid */ verify(head(this)->link.prev == 0p);
+        #if defined(USE_MPSC)
+                inline $thread * volatile & ?`next ( $thread * this )  __attribute__((const)) {
+                        return this->link.next;
+                }
+                push(this.queue, node);
+        #else
+                #if defined(__CFA_WITH_VERIFY__)
+                        /* paranoid */ verify(this.lock);
+                        /* paranoid */ verify(node->link.ts != 0);
+                        /* paranoid */ verify(node->link.next == 0p);
+                        /* paranoid */ verify(node->link.prev == 0p);
+                        /* paranoid */ verify(tail(this)->link.next == 0p);
+                        /* paranoid */ verify(head(this)->link.prev == 0p);
+                        if(this.before.link.ts == 0l) {
+                                /* paranoid */ verify(tail(this)->link.prev == head(this));
+                                /* paranoid */ verify(head(this)->link.next == tail(this));
+                        } else {
+                                /* paranoid */ verify(tail(this)->link.prev != head(this));
+                                /* paranoid */ verify(head(this)->link.next != tail(this));
+                        }
+                #endif
+                // Get the relevant nodes locally
+                $thread * tail = tail(this);
+                $thread * prev = tail->link.prev;
+                // Do the push
+                node->link.next = tail;
+                node->link.prev = prev;
+                prev->link.next = node;
+                tail->link.prev = node;
+                // Update stats
+                #if !defined(__CFA_NO_SCHED_STATS__)
+                        this.stat.diff++;
+                        this.stat.push++;
+                #endif
+                verify(node->link.next == tail(this));
+                // Check if the queue used to be empty
                 if(this.before.link.ts == 0l) {
+                        /* paranoid */ verify(tail(this)->link.prev == head(this));
+                        /* paranoid */ verify(head(this)->link.next == tail(this));
+                } else {
+                        /* paranoid */ verify(tail(this)->link.prev != head(this));
+                        /* paranoid */ verify(head(this)->link.next != tail(this));
+                }
+        #endif
+        // Get the relevant nodes locally
+        $thread * tail = tail(this);
+        $thread * prev = tail->link.prev;
+        // Do the push
+        node->link.next = tail;
+        node->link.prev = prev;
+        prev->link.next = node;
+        tail->link.prev = node;
+        // Update stats
+        #if !defined(__CFA_NO_SCHED_STATS__)
+                this.stat.diff++;
+                this.stat.push++;
+        #endif
+        verify(node->link.next == tail(this));
+        // Check if the queue used to be empty
+        if(this.before.link.ts == 0l) {
+                this.before.link.ts = node->link.ts;
+                /* paranoid */ verify(node->link.prev == head(this));
+                return true;
+        }
+        return false;
+                        this.before.link.ts = node->link.ts;
+                        /* paranoid */ verify(node->link.prev == head(this));
+                        return true;
+                }
+                return false;
+        #endif
+}
 …
 $thread * pop(__intrusive_lane_t & this) {
         /* paranoid */ verify(this.lock);
+        /* paranoid */ verify(this.before.link.ts != 0ul);
+        // Get anchors locally
+        $thread * head = head(this);
+        $thread * tail = tail(this);
+        // Get the relevant nodes locally
+        $thread * node = head->link.next;
+        $thread * next = node->link.next;
+        /* paranoid */ verify(node != tail);
+        /* paranoid */ verify(node);
+        // Do the pop
+        head->link.next = next;
+        next->link.prev = head;
+        node->link.next = 0p;
+        node->link.prev = 0p;
+        // Update head time stamp
+        this.before.link.ts = next->link.ts;
+        // Update stats
+        #ifndef __CFA_NO_SCHED_STATS__
+                this.stat.diff--;
+                this.stat.pop ++;
+        #endif
+        // Check if we emptied list and return accordingly
+        /* paranoid */ verify(tail(this)->link.next == 0p);
+        /* paranoid */ verify(head(this)->link.prev == 0p);
+        if(next == tail) {
+                /* paranoid */ verify(this.before.link.ts == 0);
+                /* paranoid */ verify(tail(this)->link.prev == head(this));
+                /* paranoid */ verify(head(this)->link.next == tail(this));
+                return node;
+        }
+        else {
+                /* paranoid */ verify(next->link.ts != 0);
+                /* paranoid */ verify(tail(this)->link.prev != head(this));
+                /* paranoid */ verify(head(this)->link.next != tail(this));
+                /* paranoid */ verify(this.before.link.ts != 0);
+                return node;
+        }
+        #if defined(USE_MPSC)
+                inline $thread * volatile & ?`next ( $thread * this )  __attribute__((const)) {
+                        return this->link.next;
+                }
+                return pop(this.queue);
+        #else
+                /* paranoid */ verify(this.before.link.ts != 0ul);
+                // Get anchors locally
+                $thread * head = head(this);
+                $thread * tail = tail(this);
+                // Get the relevant nodes locally
+                $thread * node = head->link.next;
+                $thread * next = node->link.next;
+                /* paranoid */ verify(node != tail);
+                /* paranoid */ verify(node);
+                // Do the pop
+                head->link.next = next;
+                next->link.prev = head;
+                node->link.next = 0p;
+                node->link.prev = 0p;
+                // Update head time stamp
+                this.before.link.ts = next->link.ts;
+                // Update stats
+                #ifndef __CFA_NO_SCHED_STATS__
+                        this.stat.diff--;
+                        this.stat.pop ++;
+                #endif
+                // Check if we emptied list and return accordingly
+                /* paranoid */ verify(tail(this)->link.next == 0p);
+                /* paranoid */ verify(head(this)->link.prev == 0p);
+                if(next == tail) {
+                        /* paranoid */ verify(this.before.link.ts == 0);
+                        /* paranoid */ verify(tail(this)->link.prev == head(this));
+                        /* paranoid */ verify(head(this)->link.next == tail(this));
+                        return node;
+                }
+                else {
+                        /* paranoid */ verify(next->link.ts != 0);
+                        /* paranoid */ verify(tail(this)->link.prev != head(this));
+                        /* paranoid */ verify(head(this)->link.next != tail(this));
+                        /* paranoid */ verify(this.before.link.ts != 0);
+                        return node;
+                }
+        #endif
+}
 // Check whether or not list is empty
 static inline bool is_empty(__intrusive_lane_t & this) {
+        // Cannot verify here since it may not be locked
+        return this.before.link.ts == 0;
+        #if defined(USE_MPSC)
+                return this.queue.head == 0p;
+        #else
+                // Cannot verify here since it may not be locked
+                return this.before.link.ts == 0;
+        #endif
+}
 // Return the timestamp
 static inline unsigned long long ts(__intrusive_lane_t & this) {
+        // Cannot verify here since it may not be locked
+        return this.before.link.ts;
+}
+        #if defined(USE_MPSC)
+                $thread * tl = this.queue.head;
+                if(!tl) return -1ull;
+                return tl->link.ts;
+        #else
+                // Cannot verify here since it may not be locked
+                return this.before.link.ts;
+        #endif
+}
+// Aligned timestamps which are used by the relaxed ready queue
+struct __attribute__((aligned(128))) __timestamp_t {
+        volatile unsigned long long tv;
+};
+void  ?{}(__timestamp_t & this) { this.tv = 0; }
+void ^?{}(__timestamp_t & this) {}

libcfa/src/concurrency/stats.cfa

-              rfeacef9
+              r5407cdc
 #include <inttypes.h>
 #include "bits/debug.hfa"
+#include "bits/locks.hfa"
 #include "stats.hfa"
+#include "strstream.hfa"
 #if !defined(__CFA_NO_STATISTICS__)
         void __init_stats( struct __stats_t * stats ) {
+                stats->ready.pick.push.attempt  = 0;
+                stats->ready.pick.push.success  = 0;
+                stats->ready.pick.push.local    = 0;
+                stats->ready.pick.push.lsuccess = 0;
+                stats->ready.pick.pop .probe    = 0;
+                stats->ready.pick.pop .attempt  = 0;
+                stats->ready.pick.pop .success  = 0;
+                stats->ready.pick.pop .local    = 0;
+                stats->ready.pick.pop .lsuccess = 0;
+                stats->ready.push.local.attempt = 0;
+                stats->ready.push.local.success = 0;
+                stats->ready.push.share.attempt = 0;
+                stats->ready.push.share.success = 0;
+                stats->ready.push.extrn.attempt = 0;
+                stats->ready.push.extrn.success = 0;
+                stats->ready.pop.local .attempt = 0;
+                stats->ready.pop.local .success = 0;
+                stats->ready.pop.local .elock   = 0;
+                stats->ready.pop.local .eempty  = 0;
+                stats->ready.pop.local .espec   = 0;
+                stats->ready.pop.help  .attempt = 0;
+                stats->ready.pop.help  .success = 0;
+                stats->ready.pop.help  .elock   = 0;
+                stats->ready.pop.help  .eempty  = 0;
+                stats->ready.pop.help  .espec   = 0;
+                stats->ready.pop.steal .attempt = 0;
+                stats->ready.pop.steal .success = 0;
+                stats->ready.pop.steal .elock   = 0;
+                stats->ready.pop.steal .eempty  = 0;
+                stats->ready.pop.steal .espec   = 0;
+                stats->ready.pop.search.attempt = 0;
+                stats->ready.pop.search.success = 0;
+                stats->ready.pop.search.elock   = 0;
+                stats->ready.pop.search.eempty  = 0;
+                stats->ready.pop.search.espec   = 0;
                 stats->ready.threads.migration = 0;
+                stats->ready.threads.extunpark = 0;
+                stats->ready.threads.threads   = 0;
                 stats->ready.sleep.halts   = 0;
                 stats->ready.sleep.cancels = 0;
 …
                 #if defined(CFA_HAVE_LINUX_IO_URING_H)
+                        stats->io.submit_q.submit_avg.rdy = 0;
+                        stats->io.submit_q.submit_avg.csm = 0;
+                        stats->io.submit_q.submit_avg.cnt = 0;
+                        stats->io.submit_q.look_avg.val   = 0;
+                        stats->io.submit_q.look_avg.cnt   = 0;
+                        stats->io.submit_q.look_avg.block = 0;
+                        stats->io.submit_q.alloc_avg.val   = 0;
+                        stats->io.submit_q.alloc_avg.cnt   = 0;
+                        stats->io.submit_q.alloc_avg.block = 0;
+                        stats->io.submit_q.helped = 0;
+                        stats->io.submit_q.leader = 0;
+                        stats->io.submit_q.busy   = 0;
+                        stats->io.complete_q.completed_avg.val = 0;
+                        stats->io.complete_q.completed_avg.cnt = 0;
+                        stats->io.complete_q.blocks = 0;
+                        stats->io.alloc.fast        = 0;
+                        stats->io.alloc.slow        = 0;
+                        stats->io.alloc.fail        = 0;
+                        stats->io.alloc.revoke      = 0;
+                        stats->io.alloc.block       = 0;
+                        stats->io.submit.fast       = 0;
+                        stats->io.submit.slow       = 0;
+                        stats->io.flush.external    = 0;
+                        stats->io.calls.flush       = 0;
+                        stats->io.calls.submitted   = 0;
+                        stats->io.calls.drain       = 0;
+                        stats->io.calls.completed   = 0;
+                        stats->io.calls.errors.busy = 0;
+                        stats->io.poller.sleeps     = 0;
+                #endif
+                #if defined(CFA_STATS_ARRAY)
+                        stats->array.values = alloc(CFA_STATS_ARRAY);
+                        stats->array.cnt = 0;
                 #endif
+        }
         void __tally_stats( struct __stats_t * cltr, struct __stats_t * proc ) {
+                __atomic_fetch_add( &cltr->ready.pick.push.attempt , proc->ready.pick.push.attempt , __ATOMIC_SEQ_CST ); proc->ready.pick.push.attempt  = 0;
+                __atomic_fetch_add( &cltr->ready.pick.push.success , proc->ready.pick.push.success , __ATOMIC_SEQ_CST ); proc->ready.pick.push.success  = 0;
+                __atomic_fetch_add( &cltr->ready.pick.push.local   , proc->ready.pick.push.local   , __ATOMIC_SEQ_CST ); proc->ready.pick.push.local    = 0;
+                __atomic_fetch_add( &cltr->ready.pick.push.lsuccess, proc->ready.pick.push.lsuccess, __ATOMIC_SEQ_CST ); proc->ready.pick.push.lsuccess = 0;
+                __atomic_fetch_add( &cltr->ready.pick.pop .probe   , proc->ready.pick.pop .probe   , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .probe    = 0;
+                __atomic_fetch_add( &cltr->ready.pick.pop .attempt , proc->ready.pick.pop .attempt , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .attempt  = 0;
+                __atomic_fetch_add( &cltr->ready.pick.pop .success , proc->ready.pick.pop .success , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .success  = 0;
+                __atomic_fetch_add( &cltr->ready.pick.pop .local   , proc->ready.pick.pop .local   , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .local    = 0;
+                __atomic_fetch_add( &cltr->ready.pick.pop .lsuccess, proc->ready.pick.pop .lsuccess, __ATOMIC_SEQ_CST ); proc->ready.pick.pop .lsuccess = 0;
+                __atomic_fetch_add( &cltr->ready.push.local.attempt, proc->ready.push.local.attempt, __ATOMIC_SEQ_CST ); proc->ready.push.local.attempt = 0;
+                __atomic_fetch_add( &cltr->ready.push.local.success, proc->ready.push.local.success, __ATOMIC_SEQ_CST ); proc->ready.push.local.success = 0;
+                __atomic_fetch_add( &cltr->ready.push.share.attempt, proc->ready.push.share.attempt, __ATOMIC_SEQ_CST ); proc->ready.push.share.attempt = 0;
+                __atomic_fetch_add( &cltr->ready.push.share.success, proc->ready.push.share.success, __ATOMIC_SEQ_CST ); proc->ready.push.share.success = 0;
+                __atomic_fetch_add( &cltr->ready.push.extrn.attempt, proc->ready.push.extrn.attempt, __ATOMIC_SEQ_CST ); proc->ready.push.extrn.attempt = 0;
+                __atomic_fetch_add( &cltr->ready.push.extrn.success, proc->ready.push.extrn.success, __ATOMIC_SEQ_CST ); proc->ready.push.extrn.success = 0;
+                __atomic_fetch_add( &cltr->ready.pop.local .attempt, proc->ready.pop.local .attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.local .attempt = 0;
+                __atomic_fetch_add( &cltr->ready.pop.local .success, proc->ready.pop.local .success, __ATOMIC_SEQ_CST ); proc->ready.pop.local .success = 0;
+                __atomic_fetch_add( &cltr->ready.pop.local .elock  , proc->ready.pop.local .elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.local .elock   = 0;
+                __atomic_fetch_add( &cltr->ready.pop.local .eempty , proc->ready.pop.local .eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.local .eempty  = 0;
+                __atomic_fetch_add( &cltr->ready.pop.local .espec  , proc->ready.pop.local .espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.local .espec   = 0;
+                __atomic_fetch_add( &cltr->ready.pop.help  .attempt, proc->ready.pop.help  .attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.help  .attempt = 0;
+                __atomic_fetch_add( &cltr->ready.pop.help  .success, proc->ready.pop.help  .success, __ATOMIC_SEQ_CST ); proc->ready.pop.help  .success = 0;
+                __atomic_fetch_add( &cltr->ready.pop.help  .elock  , proc->ready.pop.help  .elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.help  .elock   = 0;
+                __atomic_fetch_add( &cltr->ready.pop.help  .eempty , proc->ready.pop.help  .eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.help  .eempty  = 0;
+                __atomic_fetch_add( &cltr->ready.pop.help  .espec  , proc->ready.pop.help  .espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.help  .espec   = 0;
+                __atomic_fetch_add( &cltr->ready.pop.steal .attempt, proc->ready.pop.steal .attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.steal .attempt = 0;
+                __atomic_fetch_add( &cltr->ready.pop.steal .success, proc->ready.pop.steal .success, __ATOMIC_SEQ_CST ); proc->ready.pop.steal .success = 0;
+                __atomic_fetch_add( &cltr->ready.pop.steal .elock  , proc->ready.pop.steal .elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.steal .elock   = 0;
+                __atomic_fetch_add( &cltr->ready.pop.steal .eempty , proc->ready.pop.steal .eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.steal .eempty  = 0;
+                __atomic_fetch_add( &cltr->ready.pop.steal .espec  , proc->ready.pop.steal .espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.steal .espec   = 0;
+                __atomic_fetch_add( &cltr->ready.pop.search.attempt, proc->ready.pop.search.attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.search.attempt = 0;
+                __atomic_fetch_add( &cltr->ready.pop.search.success, proc->ready.pop.search.success, __ATOMIC_SEQ_CST ); proc->ready.pop.search.success = 0;
+                __atomic_fetch_add( &cltr->ready.pop.search.elock  , proc->ready.pop.search.elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.search.elock   = 0;
+                __atomic_fetch_add( &cltr->ready.pop.search.eempty , proc->ready.pop.search.eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.search.eempty  = 0;
+                __atomic_fetch_add( &cltr->ready.pop.search.espec  , proc->ready.pop.search.espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.search.espec   = 0;
                 __atomic_fetch_add( &cltr->ready.threads.migration , proc->ready.threads.migration , __ATOMIC_SEQ_CST ); proc->ready.threads.migration  = 0;
+                __atomic_fetch_add( &cltr->ready.threads.extunpark , proc->ready.threads.extunpark , __ATOMIC_SEQ_CST ); proc->ready.threads.extunpark  = 0;
+                __atomic_fetch_add( &cltr->ready.threads.threads   , proc->ready.threads.threads   , __ATOMIC_SEQ_CST ); proc->ready.threads.threads    = 0;
                 __atomic_fetch_add( &cltr->ready.sleep.halts       , proc->ready.sleep.halts       , __ATOMIC_SEQ_CST ); proc->ready.sleep.halts        = 0;
                 __atomic_fetch_add( &cltr->ready.sleep.cancels     , proc->ready.sleep.cancels     , __ATOMIC_SEQ_CST ); proc->ready.sleep.cancels      = 0;
 …
                 #if defined(CFA_HAVE_LINUX_IO_URING_H)
+                        __atomic_fetch_add( &cltr->io.submit_q.submit_avg.rdy     , proc->io.submit_q.submit_avg.rdy     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.rdy      = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.submit_avg.csm     , proc->io.submit_q.submit_avg.csm     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.csm      = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.submit_avg.avl     , proc->io.submit_q.submit_avg.avl     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.avl      = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.submit_avg.cnt     , proc->io.submit_q.submit_avg.cnt     , __ATOMIC_SEQ_CST ); proc->io.submit_q.submit_avg.cnt      = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.look_avg.val       , proc->io.submit_q.look_avg.val       , __ATOMIC_SEQ_CST ); proc->io.submit_q.look_avg.val        = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.look_avg.cnt       , proc->io.submit_q.look_avg.cnt       , __ATOMIC_SEQ_CST ); proc->io.submit_q.look_avg.cnt        = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.look_avg.block     , proc->io.submit_q.look_avg.block     , __ATOMIC_SEQ_CST ); proc->io.submit_q.look_avg.block      = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.alloc_avg.val      , proc->io.submit_q.alloc_avg.val      , __ATOMIC_SEQ_CST ); proc->io.submit_q.alloc_avg.val       = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.alloc_avg.cnt      , proc->io.submit_q.alloc_avg.cnt      , __ATOMIC_SEQ_CST ); proc->io.submit_q.alloc_avg.cnt       = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.alloc_avg.block    , proc->io.submit_q.alloc_avg.block    , __ATOMIC_SEQ_CST ); proc->io.submit_q.alloc_avg.block     = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.helped             , proc->io.submit_q.helped             , __ATOMIC_SEQ_CST ); proc->io.submit_q.helped              = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.leader             , proc->io.submit_q.leader             , __ATOMIC_SEQ_CST ); proc->io.submit_q.leader              = 0;
+                        __atomic_fetch_add( &cltr->io.submit_q.busy               , proc->io.submit_q.busy               , __ATOMIC_SEQ_CST ); proc->io.submit_q.busy                = 0;
+                        __atomic_fetch_add( &cltr->io.complete_q.completed_avg.val, proc->io.complete_q.completed_avg.val, __ATOMIC_SEQ_CST ); proc->io.complete_q.completed_avg.val = 0;
+                        __atomic_fetch_add( &cltr->io.complete_q.completed_avg.cnt, proc->io.complete_q.completed_avg.cnt, __ATOMIC_SEQ_CST ); proc->io.complete_q.completed_avg.cnt = 0;
+                        __atomic_fetch_add( &cltr->io.complete_q.blocks           , proc->io.complete_q.blocks           , __ATOMIC_SEQ_CST ); proc->io.complete_q.blocks            = 0;
+                        __atomic_fetch_add( &cltr->io.alloc.fast       , proc->io.alloc.fast       , __ATOMIC_SEQ_CST ); proc->io.alloc.fast        = 0;
+                        __atomic_fetch_add( &cltr->io.alloc.slow       , proc->io.alloc.slow       , __ATOMIC_SEQ_CST ); proc->io.alloc.slow        = 0;
+                        __atomic_fetch_add( &cltr->io.alloc.fail       , proc->io.alloc.fail       , __ATOMIC_SEQ_CST ); proc->io.alloc.fail        = 0;
+                        __atomic_fetch_add( &cltr->io.alloc.revoke     , proc->io.alloc.revoke     , __ATOMIC_SEQ_CST ); proc->io.alloc.revoke      = 0;
+                        __atomic_fetch_add( &cltr->io.alloc.block      , proc->io.alloc.block      , __ATOMIC_SEQ_CST ); proc->io.alloc.block       = 0;
+                        __atomic_fetch_add( &cltr->io.submit.fast      , proc->io.submit.fast      , __ATOMIC_SEQ_CST ); proc->io.submit.fast       = 0;
+                        __atomic_fetch_add( &cltr->io.submit.slow      , proc->io.submit.slow      , __ATOMIC_SEQ_CST ); proc->io.submit.slow       = 0;
+                        __atomic_fetch_add( &cltr->io.flush.external   , proc->io.flush.external   , __ATOMIC_SEQ_CST ); proc->io.flush.external    = 0;
+                        __atomic_fetch_add( &cltr->io.calls.flush      , proc->io.calls.flush      , __ATOMIC_SEQ_CST ); proc->io.calls.flush       = 0;
+                        __atomic_fetch_add( &cltr->io.calls.submitted  , proc->io.calls.submitted  , __ATOMIC_SEQ_CST ); proc->io.calls.submitted   = 0;
+                        __atomic_fetch_add( &cltr->io.calls.drain      , proc->io.calls.drain      , __ATOMIC_SEQ_CST ); proc->io.calls.drain       = 0;
+                        __atomic_fetch_add( &cltr->io.calls.completed  , proc->io.calls.completed  , __ATOMIC_SEQ_CST ); proc->io.calls.completed   = 0;
+                        __atomic_fetch_add( &cltr->io.calls.errors.busy, proc->io.calls.errors.busy, __ATOMIC_SEQ_CST ); proc->io.calls.errors.busy = 0;
+                        __atomic_fetch_add( &cltr->io.poller.sleeps    , proc->io.poller.sleeps    , __ATOMIC_SEQ_CST ); proc->io.poller.sleeps     = 0;
                 #endif
+        }
+        #define eng3(X) (ws(3, 3, unit(eng( X ))))
         void __print_stats( struct __stats_t * stats, int flags, const char * type, const char * name, void * id ) with( *stats ) {
+                char buf[1024];
+                ostrstream sstr = { buf, 1024 };
                 if( flags & CFA_STATS_READY_Q ) {
+                        double push_sur = (100.0 * ((double)ready.pick.push.success) / ready.pick.push.attempt);
+                        double pop_sur  = (100.0 * ((double)ready.pick.pop .success) / ready.pick.pop .attempt);
+                        double push_len = ((double)ready.pick.push.attempt) / ready.pick.push.success;
+                        double pop_len  = ((double)ready.pick.pop .attempt) / ready.pick.pop .success;
+                        double lpush_sur = (100.0 * ((double)ready.pick.push.lsuccess) / ready.pick.push.local);
+                        double lpop_sur  = (100.0 * ((double)ready.pick.pop .lsuccess) / ready.pick.pop .local);
+                        double lpush_len = ((double)ready.pick.push.local) / ready.pick.push.lsuccess;
+                        double lpop_len  = ((double)ready.pick.pop .local) / ready.pick.pop .lsuccess;
+                        __cfaabi_bits_print_safe( STDOUT_FILENO,
+                                "----- %s \"%s\" (%p) - Ready Q Stats -----\n"
+                                "- total threads run      : %'15" PRIu64 "\n"
+                                "- total threads scheduled: %'15" PRIu64 "\n"
+                                "- push average probe len : %'18.2lf, %'18.2lf%% (%'15" PRIu64 " attempts)\n"
+                                "- pop  average probe len : %'18.2lf, %'18.2lf%% (%'15" PRIu64 " attempts)\n"
+                                "- local push avg prb len : %'18.2lf, %'18.2lf%% (%'15" PRIu64 " attempts)\n"
+                                "- local pop  avg prb len : %'18.2lf, %'18.2lf%% (%'15" PRIu64 " attempts)\n"
+                                "- thread migrations      : %'15" PRIu64 "\n"
+                                "- Idle Sleep -\n"
+                                "-- halts                 : %'15" PRIu64 "\n"
+                                "-- cancelled halts       : %'15" PRIu64 "\n"
+                                "-- schedule wake         : %'15" PRIu64 "\n"
+                                "-- wake on exit          : %'15" PRIu64 "\n"
+                                "\n"
+                                , type, name, id
+                                , ready.pick.pop.success
+                                , ready.pick.push.success
+                                , push_len, push_sur, ready.pick.push.attempt
+                                , pop_len , pop_sur , ready.pick.pop .attempt
+                                , lpush_len, lpush_sur, ready.pick.push.local
+                                , lpop_len , lpop_sur , ready.pick.pop .local
+                                , ready.threads.migration
+                                , ready.sleep.halts, ready.sleep.cancels, ready.sleep.wakes, ready.sleep.exits
+                        );
+                        sstr | "----- " | type | "\"" | name | "\" (" | "" | id | "" | ") - Ready Q Stats -----";
+                        uint64_t totalR = ready.pop.local.success + ready.pop.help.success + ready.pop.steal.success + ready.pop.search.success;
+                        uint64_t totalS = ready.push.local.success + ready.push.share.success + ready.push.extrn.success;
+                        sstr | "- totals   : " | eng3(totalR) | "run," | eng3(totalS) | "schd (" | eng3(ready.push.extrn.success) | "ext," | eng3(ready.threads.migration) | "mig," | eng3(ready.threads.extunpark) | " eupk)";
+                        double push_len = ((double)ready.push.local.attempt + ready.push.share.attempt + ready.push.extrn.attempt) / totalS;
+                        double sLcl_len = ready.push.local.success ? ((double)ready.push.local.attempt) / ready.push.local.success : 0;
+                        double sOth_len = ready.push.share.success ? ((double)ready.push.share.attempt) / ready.push.share.success : 0;
+                        double sExt_len = ready.push.extrn.success ? ((double)ready.push.extrn.attempt) / ready.push.extrn.success : 0;
+                        sstr | "- push avg : " | ws(3, 3, push_len)
+                             | "- l: " | eng3(ready.push.local.attempt) | " (" | ws(3, 3, sLcl_len) | ")"
+                             | ", s: " | eng3(ready.push.share.attempt) | " (" | ws(3, 3, sOth_len) | ")"
+                             | ", e: " | eng3(ready.push.extrn.attempt) | " (" | ws(3, 3, sExt_len) | ")";
+                        double rLcl_pc = (100.0 * (double)ready.pop.local .success) / totalR;
+                        sstr | "- local    : " | eng3(ready.pop.local .success) | "-"| ws(3, 3, rLcl_pc) | '%'
+                             | " (" | eng3(ready.pop.local .attempt) | " try," | eng3(ready.pop.local .espec) | " spc," | eng3(ready.pop.local .elock) | " lck," | eng3(ready.pop.local .eempty) | " ept)";
+                        double rHlp_pc = (100.0 * (double)ready.pop.help  .success) / totalR;
+                        sstr | "- help     : " | eng3(ready.pop.help  .success) | "-"| ws(3, 3, rHlp_pc) | '%'
+                             | " (" | eng3(ready.pop.help  .attempt) | " try," | eng3(ready.pop.help  .espec) | " spc," | eng3(ready.pop.help  .elock) | " lck," | eng3(ready.pop.help  .eempty) | " ept)";
+                        double rStl_pc = (100.0 * (double)ready.pop.steal .success) / totalR;
+                        sstr | "- steal    : " | eng3(ready.pop.steal .success) | "-"| ws(3, 3, rStl_pc) | '%'
+                             | " (" | eng3(ready.pop.steal .attempt) | " try," | eng3(ready.pop.steal .espec) | " spc," | eng3(ready.pop.steal .elock) | " lck," | eng3(ready.pop.steal .eempty) | " ept)";
+                        double rSch_pc = (100.0 * (double)ready.pop.search.success) / totalR;
+                        sstr | "- search   : " | eng3(ready.pop.search.success) | "-"| ws(3, 3, rSch_pc) | '%'
+                             | " (" | eng3(ready.pop.search.attempt) | " try," | eng3(ready.pop.search.espec) | " spc," | eng3(ready.pop.search.elock) | " lck," | eng3(ready.pop.search.eempty) | " ept)";
+                        sstr | "- Idle Slp : " | eng3(ready.sleep.halts) | "halt," | eng3(ready.sleep.cancels) | "cancel," | eng3(ready.sleep.wakes) | "wake," | eng3(ready.sleep.exits) | "exit";
+                        sstr | nl;
+                }
                 #if defined(CFA_HAVE_LINUX_IO_URING_H)
                         if( flags & CFA_STATS_IO ) {
+                                double avgrdy = ((double)io.submit_q.submit_avg.rdy) / io.submit_q.submit_avg.cnt;
+                                double avgcsm = ((double)io.submit_q.submit_avg.csm) / io.submit_q.submit_avg.cnt;
+                                double lavgv = 0;
+                                double lavgb = 0;
+                                if(io.submit_q.look_avg.cnt != 0) {
+                                        lavgv = ((double)io.submit_q.look_avg.val  ) / io.submit_q.look_avg.cnt;
+                                        lavgb = ((double)io.submit_q.look_avg.block) / io.submit_q.look_avg.cnt;
+                                }
+                                double aavgv = 0;
+                                double aavgb = 0;
+                                if(io.submit_q.alloc_avg.cnt != 0) {
+                                        aavgv = ((double)io.submit_q.alloc_avg.val  ) / io.submit_q.alloc_avg.cnt;
+                                        aavgb = ((double)io.submit_q.alloc_avg.block) / io.submit_q.alloc_avg.cnt;
+                                }
+                                __cfaabi_bits_print_safe( STDOUT_FILENO,
+                                        "----- %s \"%s\" (%p) - I/O Stats -----\n"
+                                        "- total submit calls     : %'15" PRIu64 "\n"
+                                        "- avg ready entries      : %'18.2lf\n"
+                                        "- avg submitted entries  : %'18.2lf\n"
+                                        "- total helped entries   : %'15" PRIu64 "\n"
+                                        "- total leader entries   : %'15" PRIu64 "\n"
+                                        "- total busy submit      : %'15" PRIu64 "\n"
+                                        "- total ready search     : %'15" PRIu64 "\n"
+                                        "- avg ready search len   : %'18.2lf\n"
+                                        "- avg ready search block : %'18.2lf\n"
+                                        "- total alloc search     : %'15" PRIu64 "\n"
+                                        "- avg alloc search len   : %'18.2lf\n"
+                                        "- avg alloc search block : %'18.2lf\n"
+                                        "- total wait calls       : %'15" PRIu64 "\n"
+                                        "- avg completion/wait    : %'18.2lf\n"
+                                        "- total completion blocks: %'15" PRIu64 "\n"
+                                        "\n"
+                                        , type,  name, id
+                                        , io.submit_q.submit_avg.cnt
+                                        , avgrdy, avgcsm
+                                        , io.submit_q.helped, io.submit_q.leader, io.submit_q.busy
+                                        , io.submit_q.look_avg.cnt
+                                        , lavgv, lavgb
+                                        , io.submit_q.alloc_avg.cnt
+                                        , aavgv, aavgb
+                                        , io.complete_q.completed_avg.cnt
+                                        , ((double)io.complete_q.completed_avg.val) / io.complete_q.completed_avg.cnt
+                                        , io.complete_q.blocks
+                                );
+                                sstr | "----- " | type | "\"" | name | "\" (" | "" | id | "" | ") - I/O Stats -----";
+                                uint64_t total_allocs = io.alloc.fast + io.alloc.slow;
+                                double avgfasta = (100.0 * (double)io.alloc.fast) / total_allocs;
+                                sstr | "- total allocations : " | eng3(io.alloc.fast) | "fast," | eng3(io.alloc.slow) | "slow (" | ws(3, 3, avgfasta) | "%)";
+                                sstr | "-     failures      : " | eng3(io.alloc.fail) | "oom, " | eng3(io.alloc.revoke) | "rvk, " | eng3(io.alloc.block) | "blk";
+                                uint64_t total_submits = io.submit.fast + io.submit.slow;
+                                double avgfasts = (100.0 * (double)io.submit.fast) / total_submits;
+                                sstr | "- total submits     : " | eng3(io.submit.fast) | "fast," | eng3(io.submit.slow) | "slow (" | ws(3, 3, avgfasts) | "%)";
+                                sstr | "- flush external    : " | eng3(io.flush.external);
+                                sstr | "- io_uring_enter    : " | eng3(io.calls.flush) | " (" | eng3(io.calls.drain) | ", " | eng3(io.calls.errors.busy) | " EBUSY)";
+                                double avgsubs = ((double)io.calls.submitted) / io.calls.flush;
+                                double avgcomp = ((double)io.calls.completed) / io.calls.drain;
+                                sstr | "-     submits       : " | eng3(io.calls.submitted) | "(" | ws(3, 3, avgsubs) | "/flush)";
+                                sstr | "-     completes     : " | eng3(io.calls.completed) | "(" | ws(3, 3, avgcomp) | "/drain)";
+                                sstr | "- poller sleeping   : " | eng3(io.poller.sleeps);
+                                sstr | nl;
+                        }
                 #endif
+                if(flags) write( sstr, stdout );
+        }
+        #if defined(CFA_STATS_ARRAY)
+                extern "C" {
+                        #include <stdio.h>
+                        #include <errno.h>
+                        #include <sys/stat.h>
+                        #include <fcntl.h>
+                }
+                void __flush_stat( struct __stats_t * this, const char * name, void * handle) {
+                        int ret = mkdir(".cfadata", 0755);
+                        if(ret < 0 && errno != EEXIST) abort("Failed to create directory .cfadata: %d\n", errno);
+                        char filename[100];
+                        snprintf(filename, 100, ".cfadata/%s%p.data", name, handle);
+                        int fd = open(filename, O_WRONLY | O_APPEND | O_CREAT, 0644);
+                        if(fd < 0) abort("Failed to create file %s: %d\n", filename, errno);
+                        for(i; this->array.cnt) {
+                                char line[100];
+                                size_t n = snprintf(line, 100, "%llu, %lld\n", this->array.values[i].ts, this->array.values[i].value);
+                                write(fd, line, n);
+                        }
+                        this->array.cnt = 0;
+                        close(fd);
+                }
+                static __spinlock_t stats_lock;
+                void __push_stat( struct __stats_t * this, int64_t value, bool external, const char * name, void * handle ) {
+                        if(external) lock(stats_lock __cfaabi_dbg_ctx2);
+                        if( this->array.cnt >= CFA_STATS_ARRAY ) __flush_stat( this, name, handle );
+                        size_t idx = this->array.cnt;
+                        this->array.cnt++;
+                        if(external) unlock(stats_lock);
+                        this->array.values[idx].ts = rdtscl();
+                        this->array.values[idx].value = value;
+                }
+        #endif
 #endif

libcfa/src/concurrency/stats.hfa

-              rfeacef9
+              r5407cdc
 #pragma once
+// #define CFA_STATS_ARRAY 10000
 #include <stdint.h>
 …
         static inline void __print_stats( struct __stats_t *, int, const char *, const char *, void * ) {}
 #else
+        struct __stats_readyQ_pop_t {
+                // number of attemps at poping something
+                volatile uint64_t attempt;
+        struct __attribute__((aligned(64))) __stats_readQ_t {
+                // number of successes at poping
+                volatile uint64_t success;
+                // number of attempts failed due to the lock being held
+                volatile uint64_t elock;
+                // number of attempts failed due to the queue being empty (lock held)
+                volatile uint64_t eempty;
+                // number of attempts failed due to the queue looking empty (lock not held)
+                volatile uint64_t espec;
+        };
+        struct __attribute__((aligned(64))) __stats_readyQ_t {
+                // Push statistic
                 struct {
-                        // Push statistic
                         struct {
                                 // number of attemps at pushing something
+                                // number of attemps at pushing something to preferred queues
                                 volatile uint64_t attempt;
                                 // number of successes at pushing
+                                // number of successes at pushing to preferred queues
                                 volatile uint64_t success;
+                        }
+                        // Stats for local queue within cluster
+                        local,
                                 // number of attemps at pushing something to preferred queues
                                 volatile uint64_t local;
+                        // Stats for non-local queues within cluster
+                        share,
                                 // number of successes at pushing to preferred queues
                                 volatile uint64_t lsuccess;
                         } push;
+                        // Stats from outside cluster
+                        extrn;
+                } push;
+                        // Pop statistic
+                        struct {
+                                // number of reads of the mask
+                                // picking an empty __cfa_readyQ_mask_t counts here
+                                // but not as an attempt
+                                volatile uint64_t probe;
+                // Pop statistic
+                struct {
+                        // pop from local queue
+                        __stats_readyQ_pop_t local;
                                 // number of attemps at poping something
                                 volatile uint64_t attempt;
+                        // pop before looking at local queue
+                        __stats_readyQ_pop_t help;
                                 // number of successes at poping
                                 volatile uint64_t success;
+                        // pop from some other queue
+                        __stats_readyQ_pop_t steal;
+                                // number of attemps at poping something to preferred queues
+                                volatile uint64_t local;
+                        // pop when searching queues sequentially
+                        __stats_readyQ_pop_t search;
+                } pop;
-                                // number of successes at poping to preferred queues
-                                volatile uint64_t lsuccess;
-                        } pop;
-                } pick;
                 struct {
                         volatile uint64_t migration;
+                        volatile uint64_t extunpark;
+                        volatile  int64_t threads; // number of threads in the system, includes only local change
                 } threads;
                 struct {
 …
                 struct __attribute__((aligned(64))) __stats_io_t{
                         struct {
+                                volatile uint64_t fast;
+                                volatile uint64_t slow;
+                                volatile uint64_t fail;
+                                volatile uint64_t revoke;
+                                volatile uint64_t block;
+                        } alloc;
+                        struct {
+                                volatile uint64_t fast;
+                                volatile uint64_t slow;
+                        } submit;
+                        struct {
+                                volatile uint64_t external;
+                        } flush;
+                        struct {
+                                volatile uint64_t drain;
+                                volatile uint64_t completed;
+                                volatile uint64_t flush;
+                                volatile uint64_t submitted;
                                 struct {
+                                        volatile uint64_t rdy;
+                                        volatile uint64_t csm;
+                                        volatile uint64_t avl;
+                                        volatile uint64_t cnt;
+                                } submit_avg;
+                                struct {
+                                        volatile uint64_t val;
+                                        volatile uint64_t cnt;
+                                        volatile uint64_t block;
+                                } look_avg;
+                                struct {
+                                        volatile uint64_t val;
+                                        volatile uint64_t cnt;
+                                        volatile uint64_t block;
+                                } alloc_avg;
+                                volatile uint64_t helped;
+                                volatile uint64_t leader;
+                                volatile uint64_t busy;
+                        } submit_q;
+                                        volatile uint64_t busy;
+                                } errors;
+                        } calls;
                         struct {
+                                struct {
+                                        volatile uint64_t val;
+                                        volatile uint64_t cnt;
+                                } completed_avg;
+                                volatile uint64_t blocks;
+                        } complete_q;
+                                volatile uint64_t sleeps;
+                        } poller;
+                };
+        #endif
+        #if defined(CFA_STATS_ARRAY)
+                struct __stats_elem_t {
+                        long long int ts;
+                        int64_t value;
                 };
         #endif
         struct __attribute__((aligned(128))) __stats_t {
                 __stats_readQ_t ready;
+                __stats_readyQ_t ready;
                 #if defined(CFA_HAVE_LINUX_IO_URING_H)
                         __stats_io_t    io;
                 #endif
+                #if defined(CFA_STATS_ARRAY)
+                        struct {
+                                __stats_elem_t * values;
+                                volatile size_t cnt;
+                        } array;
+                #endif
         };
 …
         void __tally_stats( struct __stats_t *, struct __stats_t * );
         void __print_stats( struct __stats_t *, int, const char *, const char *, void * );
+        #if defined(CFA_STATS_ARRAY)
+                void __push_stat ( struct __stats_t *, int64_t value, bool external, const char * name, void * handle);
+                void __flush_stat( struct __stats_t *, const char *, void * );
+        #else
+                static inline void __push_stat ( struct __stats_t *, int64_t, bool, const char *, void * ) {}
+                static inline void __flush_stat( struct __stats_t *, const char *, void * ) {}
+        #endif
 #endif

libcfa/src/concurrency/thread.cfa

-              rfeacef9
+              r5407cdc
         link.next = 0p;
         link.prev = 0p;
+        link.preferred = -1;
+        link.preferred = -1u;
+        last_proc = 0p;
         #if defined( __CFA_WITH_VERIFY__ )
                 canary = 0x0D15EA5E0D15EA5Ep;
 …
+}
-FORALL_DATA_INSTANCE(ThreadCancelled, (thread_t &), (thread_t))
 forall(T &)
 void copy(ThreadCancelled(T) * dst, ThreadCancelled(T) * src) {
 …
 forall(T &)
 const char * msg(ThreadCancelled(T) *) {
         return "ThreadCancelled";
+        return "ThreadCancelled(...)";
+}
 forall(T &)
 static void default_thread_cancel_handler(ThreadCancelled(T) & ) {
+        // Improve this error message, can I do formatting?
         abort( "Unhandled thread cancellation.\n" );
+}
+forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)))
+forall(T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 void ?{}( thread_dtor_guard_t & this,
                 T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
         $monitor * m = get_monitor(thrd);
+        $monitor * m = get_monitor(thrd);
         $thread * desc = get_thread(thrd);
 …
+        }
         desc->state = Cancelled;
         void(*defaultResumptionHandler)(ThreadCancelled(T) &) =
+        void(*defaultResumptionHandler)(ThreadCancelled(T) &) =
                 join ? cancelHandler : default_thread_cancel_handler;
+        // TODO: Remove explitate vtable set once trac#186 is fixed.
         ThreadCancelled(T) except;
+        // TODO: Remove explitate vtable set once trac#186 is fixed.
+        except.virtual_table = &get_exception_vtable(&except);
+        except.virtual_table = &_default_vtable;
         except.the_thread = &thrd;
         except.the_exception = __cfaehm_cancellation_exception( cancellation );
+        throwResume except;
+        // Why is this cast required?
+        throwResume (ThreadCancelled(T) &)except;
         except.the_exception->virtual_table->free( except.the_exception );
 …
         /* paranoid */ verify( this_thrd->context.SP );
         __schedule_thread( this_thrd );
         enable_interrupts( __cfaabi_dbg_ctx );
+        schedule_thread$( this_thrd );
+        enable_interrupts();
+}
 …
 //-----------------------------------------------------------------------------
+forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)))
+forall(T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 T & join( T & this ) {
         thread_dtor_guard_t guard = { this, defaultResumptionHandler };
 …
         disable_interrupts();
         uint64_t ret = __tls_rand();
         enable_interrupts( __cfaabi_dbg_ctx );
+        enable_interrupts();
         return ret;
+}

libcfa/src/concurrency/thread.hfa

-              rfeacef9
+              r5407cdc
 };
 FORALL_DATA_EXCEPTION(ThreadCancelled, (thread_t &), (thread_t)) (
+EHM_FORALL_EXCEPTION(ThreadCancelled, (thread_t &), (thread_t)) (
         thread_t * the_thread;
         exception_t * the_exception;
 …
 forall(T &)
 const char * msg(ThreadCancelled(T) *);
-// define that satisfies the trait without using the thread keyword
-#define DECL_THREAD(X) $thread* get_thread(X& this) __attribute__((const)) { return &this.__thrd; } void main(X& this)
 // Inline getters for threads/coroutines/monitors
 …
 };
+forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T)) )
+forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled, (T))
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
 void ^?{}( thread_dtor_guard_t & this );
 …
 //----------
 // join
+forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T)) )
+forall( T & | is_thread(T) | IS_RESUMPTION_EXCEPTION(ThreadCancelled, (T))
+    | { EHM_DEFAULT_VTABLE(ThreadCancelled, (T)); })
 T & join( T & this );

libcfa/src/containers/list.hfa

-              rfeacef9
+              r5407cdc
                 (this.is_terminator){ 1 };
+        }
+        forall ( tInit | { void ?{}( $mgd_link(tE) &, tInit); } )
+        static inline void ?=?( $mgd_link(tE) &this, tInit i ) {
+                ^?{}( this );
+                ?{}( this, i );
+        static inline void ?=?( $mgd_link(tE) &this, tE* elem ) {
+                this.elem = elem ;
+                this.terminator = 0p;
+                this.is_terminator = 0;
+        }
+        static inline void ?=?( $mgd_link(tE) &this, void * terminator ) {
+                this.elem = 0p;
+                this.terminator = terminator;
+                this.is_terminator = 1;
+        }
         struct $dlinks {
 …
         static inline void insert_after(Tnode &list_pos, Telem &to_insert) {
                 assert (&list_pos != 0p);
                 assert (&to_insert != 0p);
+                verify (&list_pos != 0p);
+                verify (&to_insert != 0p);
                 Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
                 assert($prev_link(singleton_to_insert).elem == 0p);
                 assert($next_link(singleton_to_insert).elem == 0p);
+                verify($prev_link(singleton_to_insert).elem == 0p);
+                verify($next_link(singleton_to_insert).elem == 0p);
                 $prev_link(singleton_to_insert) = & $tempcv_n2e(list_pos);
                 $next_link(singleton_to_insert) = $next_link(list_pos);
 …
         static inline void insert_before(Tnode &list_pos, Telem &to_insert) {
                 assert (&list_pos != 0p);
                 assert (&to_insert != 0p);
+                verify (&list_pos != 0p);
+                verify (&to_insert != 0p);
                 Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
                 assert($prev_link(singleton_to_insert).elem == 0p);
                 assert($next_link(singleton_to_insert).elem == 0p);
+                verify($prev_link(singleton_to_insert).elem == 0p);
+                verify($next_link(singleton_to_insert).elem == 0p);
                 $next_link(singleton_to_insert) = & $tempcv_n2e(list_pos);
                 $prev_link(singleton_to_insert) = $prev_link(list_pos);
 …
     static inline void insert_first(dlist(Tnode, Telem) &list, Telem &to_insert) {
                 assert (&list != 0p);
                 assert (&to_insert != 0p);
+                verify (&list != 0p);
+                verify (&to_insert != 0p);
                 Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
                 assert($prev_link(singleton_to_insert).elem == 0p);
                 assert($next_link(singleton_to_insert).elem == 0p);
+                verify($prev_link(singleton_to_insert).elem == 0p);
+                verify($next_link(singleton_to_insert).elem == 0p);
                 $prev_link(singleton_to_insert) = (void*) &list;
 …
     static inline void insert_last(dlist(Tnode, Telem) &list, Telem &to_insert) {
                 assert (&list != 0p);
                 assert (&to_insert != 0p);
+                verify (&list != 0p);
+                verify (&to_insert != 0p);
                 Tnode &singleton_to_insert = $tempcv_e2n(to_insert);
                 assert($next_link(singleton_to_insert).elem == 0p);
                 assert($prev_link(singleton_to_insert).elem == 0p);
+                verify($next_link(singleton_to_insert).elem == 0p);
+                verify($prev_link(singleton_to_insert).elem == 0p);
                 $next_link(singleton_to_insert) = (void*) &list;
 …
     static inline void remove(Tnode &list_pos) {
                 assert( &list_pos != 0p );
+                verify( &list_pos != 0p );
                 $mgd_link(Telem) &incoming_from_prev = *0p;
 …
         static inline bool ?`is_empty(dlist(Tnode, Telem) &list) {
                 assert( &list != 0p );
+                verify( &list != 0p );
                 $dlinks(Telem) *listLinks = & list.$links;
                 if (listLinks->next.is_terminator) {
                         assert(listLinks->prev.is_terminator);
                         assert(listLinks->next.terminator);
                         assert(listLinks->prev.terminator);
+                        verify(listLinks->prev.is_terminator);
+                        verify(listLinks->next.terminator);
+                        verify(listLinks->prev.terminator);
                         return true;
                 } else {
                         assert(!listLinks->prev.is_terminator);
                         assert(listLinks->next.elem);
                         assert(listLinks->prev.elem);
+                        verify(!listLinks->prev.is_terminator);
+                        verify(listLinks->next.elem);
+                        verify(listLinks->prev.elem);
                         return false;
+                }
 …
         static inline Telem & pop_first(dlist(Tnode, Telem) &list) {
                 assert( &list != 0p );
                 assert( !list`is_empty );
+                verify( &list != 0p );
+                verify( !list`is_empty );
                 $dlinks(Telem) *listLinks = & list.$links;
                 Telem & first = *listLinks->next.elem;
 …
         static inline Telem & pop_last(dlist(Tnode, Telem) &list) {
                 assert( &list != 0p );
                 assert( !list`is_empty );
+                verify( &list != 0p );
+                verify( !list`is_empty );
                 $dlinks(Telem) *listLinks = & list.$links;
                 Telem & last = *listLinks->prev.elem;

libcfa/src/exception.c

-              rfeacef9
+              r5407cdc
 // Created On       : Mon Jun 26 15:13:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Oct 27 16:27:00 2020
 // Update Count     : 35
+// Last Modified On : Wed Feb 24 13:40:00 2021
+// Update Count     : 36
 //
 …
 #include "concurrency/invoke.h"
 #include "stdhdr/assert.h"
+#include "virtual.h"
 #if defined( __ARM_ARCH )
 …
 const _Unwind_Exception_Class __cfaehm_exception_class = 0x4c50575500414643;
+// Base exception vtable is abstract, you should not have base exceptions.
+struct __cfaehm_base_exception_t_vtable
+                ___cfaehm_base_exception_t_vtable_instance = {
+        .parent = NULL,
+        .size = 0,
+        .copy = NULL,
+        .free = NULL,
+        .msg = NULL
+// Base Exception type id:
+struct __cfa__parent_vtable __cfatid_exception_t = {
+        NULL,
 };

libcfa/src/exception.h

-              rfeacef9
+              r5407cdc
 // Created On       : Mon Jun 26 15:11:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Oct 27 14:45:00 2020
 // Update Count     : 11
+// Last Modified On : Thr Apr  8 15:20:00 2021
+// Update Count     : 12
 //
 …
 struct __cfaehm_base_exception_t;
 typedef struct __cfaehm_base_exception_t exception_t;
+struct __cfa__parent_vtable;
 struct __cfaehm_base_exception_t_vtable {
         const struct __cfaehm_base_exception_t_vtable * parent;
+        const struct __cfa__parent_vtable * __cfavir_typeid;
         size_t size;
         void (*copy)(struct __cfaehm_base_exception_t *this,
 …
         struct __cfaehm_base_exception_t_vtable const * virtual_table;
 };
+extern struct __cfaehm_base_exception_t_vtable
+        ___cfaehm_base_exception_t_vtable_instance;
+extern struct __cfa__parent_vtable __cfatid_exception_t;
 …
         /* The first field must be a pointer to a virtual table.
          * That virtual table must be a decendent of the base exception virtual table.
+         * The virtual table must point at the prober type-id.
+         * None of these can be enforced in an assertion.
          */
-        virtualT const & get_exception_vtable(exceptT *);
-        // Always returns the virtual table for this type (associated types hack).
 };

libcfa/src/exception.hfa

-              rfeacef9
+              r5407cdc
 // Created On       : Thu Apr  7 10:25:00 2020
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Aug  4 16:22:00 2020
 // Update Count     : 3
+// Last Modified On : Thr Apr  8 15:16:00 2021
+// Update Count     : 4
 //
 …
 // -----------------------------------------------------------------------------------------------
+// TRIVIAL_EXCEPTION_DECLARATION(exception_name);
+// Declare a trivial exception, one that adds no fields or features.
+// This will make the exception visible and may go in a .hfa or .cfa file.
+#define TRIVIAL_EXCEPTION_DECLARATION(...) \
+        _EXC_DISPATCH(_TRIVIAL_EXCEPTION_DECLARATION, __VA_ARGS__)
+// EHM_EXCEPTION(exception_name)(fields...);
+// Create an exception (a virtual structure that inherits from exception_t)
+// with the given name and fields.
+#define EHM_EXCEPTION(exception_name) \
+        _EHM_TYPE_ID_STRUCT(exception_name, ); \
+        _EHM_TYPE_ID_VALUE(exception_name, ); \
+        _EHM_VIRTUAL_TABLE_STRUCT(exception_name, , ); \
+        _EHM_EXCEPTION_STRUCT(exception_name, , )
 // TRIVIAL_EXCEPTION_INSTANCE(exception_name);
 // Create the trival exception. This must be used exactly once and should be used in a .cfa file,
+// as it creates the unique instance of the virtual table.
 #define TRIVIAL_EXCEPTION_INSTANCE(...) _EXC_DISPATCH(_TRIVIAL_EXCEPTION_INSTANCE, __VA_ARGS__)
+// EHM_EXTERN_VTABLE(exception_name, table_name);
+// Forward declare a virtual table called table_name for exception_name type.
+#define EHM_EXTERN_VTABLE(exception_name, table_name) \
+        _EHM_EXTERN_VTABLE(exception_name, , table_name)
+// TRIVIAL_EXCEPTION(exception_name[, parent_name]);
+// Does both of the above, a short hand if the exception is only used in one .cfa file.
+// For legacy reasons this is the only one that official supports having a parent other than the
+// base exception. This feature may be removed or changed.
+#define TRIVIAL_EXCEPTION(...) \
+        _EXC_DISPATCH(_TRIVIAL_EXCEPTION_DECLARATION, __VA_ARGS__); \
+        _EXC_DISPATCH(_TRIVIAL_EXCEPTION_INSTANCE, __VA_ARGS__)
+// EHM_VIRTUAL_TABLE(exception_name, table_name);
+// Define a virtual table called table_name for exception_name type.
+#define EHM_VIRTUAL_TABLE(exception_name, table_name) \
+        _EHM_DEFINE_COPY(exception_name, ) \
+        _EHM_DEFINE_MSG(exception_name, ) \
+        _EHM_VIRTUAL_TABLE(exception_name, , table_name)
+// FORALL_TRIVIAL_EXCEPTION(exception_name, (assertions...), (parameters...));
+// Forward declare a polymorphic but otherwise trivial exception type. You must provide the entire
+// assertion list (exactly what would go in the forall clause) and parameters list (only the
+// parameter names from the assertion list, same order and comma seperated). This should be
+// visible where ever use the exception. This just generates the polymorphic framework, see
+// POLY_VTABLE_DECLARATION to allow instantiations.
+#define FORALL_TRIVIAL_EXCEPTION(exception_name, assertions, parameters) \
+        _FORALL_TRIVIAL_EXCEPTION(exception_name, __cfaehm_base_exception_t, assertions, parameters, )
+// EHM_FORALL_EXCEPTION(exception_name, (assertions), (parameters))(fields...);
+// As EHM_EXCEPTION but for polymorphic types instead of monomorphic ones.
+// The assertions list should include all polymorphic parameters and
+// assertions inside a parentisized list. Parameters should include all the
+// polymorphic parameter names inside a parentisized list (same order).
+#define EHM_FORALL_EXCEPTION(exception_name, assertions, parameters) \
+        _EHM_TYPE_ID_STRUCT(exception_name, forall assertions); \
+        _EHM_VIRTUAL_TABLE_STRUCT(exception_name, forall assertions, parameters); \
+        _EHM_EXCEPTION_STRUCT(exception_name, forall assertions, parameters)
+// FORALL_TRIVIAL_INSTANCE(exception_name, (assertions...), (parameters...))
+// Create the forall trivial exception. The assertion list and parameters must match.
+// There must be exactly one use of this in a program for each exception type. This just
+// generates the polymorphic framework, see POLY_VTABLE_INSTANCE to allow instantiations.
+#define FORALL_TRIVIAL_INSTANCE(exception_name, assertions, parameters) \
+        _FORALL_CTOR0_INSTANCE(exception_name, assertions, parameters)
+// EHM_FORALL_EXTERN_VTABLE(exception_name, (arguments), table_name);
+// As EHM_EXTERN_VTABLE but for polymorphic types instead of monomorphic ones.
+// Arguments should be the parentisized list of polymorphic arguments.
+#define EHM_FORALL_EXTERN_VTABLE(exception_name, arguments, table_name) \
+        _EHM_EXTERN_VTABLE(exception_name, arguments, table_name)
+// DATA_EXCEPTION(exception_name)(fields...);
+// Forward declare an exception that adds fields but no features. The added fields go in the
+// second argument list. The virtual table instance must be provided later (see VTABLE_INSTANCE).
+#define DATA_EXCEPTION(...) _EXC_DISPATCH(_DATA_EXCEPTION, __VA_ARGS__)
+// EHM_FORALL_VIRTUAL_TABLE(exception_name, (arguments), table_name);
+// As EHM_VIRTUAL_TABLE but for polymorphic types instead of monomorphic ones.
+// Arguments should be the parentisized list of polymorphic arguments.
+#define EHM_FORALL_VIRTUAL_TABLE(exception_name, arguments, table_name) \
+        _EHM_TYPE_ID_VALUE(exception_name, arguments); \
+        _EHM_DEFINE_COPY(exception_name, arguments) \
+        _EHM_DEFINE_MSG(exception_name, arguments) \
+        _EHM_VIRTUAL_TABLE(exception_name, arguments, table_name)
+// FORALL_DATA_EXCEPTION(exception_name, (assertions...), (parameters...))(fields...);
+// Define a polymorphic exception that adds fields but no additional features. The assertion list
+// and matching parameters must match. Then you can give the list of fields. This should be
+// visible where ever you use the exception. This just generates the polymorphic framework, see
+// POLY_VTABLE_DECLARATION to allow instantiations.
+#define FORALL_DATA_EXCEPTION(exception_name, assertions, parameters) \
+        _FORALL_DATA_EXCEPTION(exception_name, __cfaehm_base_exception_t, assertions, parameters, )
+// FORALL_DATA_INSTANCE(exception_name, (assertions...), (parameters...))
+// Create a polymorphic data exception. The assertion list and parameters must match. This should
+// appear once in each program. This just generates the polymorphic framework, see
+// POLY_VTABLE_INSTANCE to allow instantiations.
+#define FORALL_DATA_INSTANCE(exception_name, assertions, parameters) \
+        _FORALL_CTOR0_INSTANCE(exception_name, assertions, parameters)
+// VTABLE_DECLARATION(exception_name)([new_features...]);
+// Declare a virtual table type for an exception with exception_name. You may also add features
+// (fields on the virtual table) by including them in the second list.
+#define VTABLE_DECLARATION(...) _EXC_DISPATCH(_VTABLE_DECLARATION, __VA_ARGS__)
+// VTABLE_INSTANCE(exception_name)(msg [, others...]);
+// Create the instance of the virtual table. There must be exactly one instance of a virtual table
+// for each exception type. This fills in most of the fields of the virtual table (uses ?=? and
+// ^?{}) but you must provide the message function and any other fields added in the declaration.
+#define VTABLE_INSTANCE(...) _EXC_DISPATCH(_VTABLE_INSTANCE, __VA_ARGS__)
+// FORALL_VTABLE_DECLARATION(exception_name, (assertions...), (parameters...))([new_features...]);
+// Declare a polymorphic virtual table type for an exception with exception_name, the given
+// assertions and parameters. You may also add features (fields on the virtual table). This just
+// generates the polymorphic framework, see POLY_VTABLE_DECLARATION to allow instantiations.
+#define FORALL_VTABLE_DECLARATION(exception_name, assertions, parameters) \
+        _FORALL_VTABLE_DECLARATION(exception_name, __cfaehm_base_exception_t, assertions, parameters, )
+// POLY_VTABLE_DECLARATION(exception_name, types...);
+// Declares that an instantiation for this exception exists for the given types. This should be
+// visible anywhere you use the instantiation of the exception is used.
+#define POLY_VTABLE_DECLARATION(exception_name, ...) \
+        VTABLE_TYPE(exception_name)(__VA_ARGS__) const & get_exception_vtable(exception_name(__VA_ARGS__) *); \
+        extern VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name)
+// POLY_VTABLE_INSTANCE(exception_name, types...)(msg [, others...]);
+// Creates an instantiation for the given exception for the given types. This should occur only
+// once in the entire program. You must fill in all features, message and any others given in the
+// initial declaration.
+#define POLY_VTABLE_INSTANCE(exception_name, ...) \
+        _POLY_VTABLE_INSTANCE(exception_name, __cfaehm_base_exception_t, __VA_ARGS__)
+// VTABLE_TYPE(exception_name) | VTABLE_NAME(exception_name)
+// Get the name of the vtable type or the name of the vtable instance for an exception type.
+#define VTABLE_TYPE(exception_name) struct _GLUE2(exception_name,_vtable)
+#define VTABLE_NAME(exception_name) _GLUE3(_,exception_name,_vtable_instance)
+// VTABLE_FIELD(exception_name);
+// FORALL_VTABLE_FIELD(exception_name, (parameters-or-types));
+// The declaration of the virtual table field. Should be the first declaration in a virtual type.
+#define VTABLE_FIELD(exception_name) VTABLE_TYPE(exception_name) const * virtual_table
+#define FORALL_VTABLE_FIELD(exception_name, parameters) \
+        VTABLE_TYPE(exception_name) parameters const * virtual_table
+// VTABLE_INIT(object_reference, exception_name);
+// Sets a virtual table field on an object to the virtual table instance for the type.
+#define VTABLE_INIT(this, exception_name) (this).virtual_table = &VTABLE_NAME(exception_name)
+// VTABLE_ASSERTION(exception_name, (parameters...))
+// The assertion that there is an instantiation of the vtable for the exception and types.
+#define VTABLE_ASSERTION(exception_name, parameters) \
+        { VTABLE_TYPE(exception_name) parameters VTABLE_NAME(exception_name); }
+// EHM_DEFAULT_VTABLE(exception_name, (arguments))
+// Create a declaration for a (possibly polymorphic) default vtable.
+#define EHM_DEFAULT_VTABLE(exception_name, arguments) \
+        _EHM_VTABLE_TYPE(exception_name) arguments & const _default_vtable
 // IS_EXCEPTION(exception_name [, (...parameters)])
 …
 #define IS_TERMINATION_EXCEPTION(...) _IS_EXCEPTION(is_termination_exception, __VA_ARGS__, , ~)
+// All internal helper macros begin with an underscore.
+#define _CLOSE(...) __VA_ARGS__ }
+#define _GLUE2(left, right) left##right
+#define _GLUE3(left, middle, right) left##middle##right
+#define _EXC_DISPATCH(to, ...) to(__VA_ARGS__,__cfaehm_base_exception_t,)
+#define _UNPACK(...) __VA_ARGS__
+// Macros starting with a leading underscore are internal.
+#define _TRIVIAL_EXCEPTION_DECLARATION(exception_name, parent_name, ...) \
+        _VTABLE_DECLARATION(exception_name, parent_name)(); \
+        struct exception_name { \
+                VTABLE_FIELD(exception_name); \
+        }; \
+        void ?{}(exception_name & this); \
+        const char * _GLUE2(exception_name,_msg)(exception_name * this)
+// Create an exception type definition. must be tailing, can be polymorphic.
+#define _EHM_EXCEPTION_STRUCT(exception_name, forall_clause, parameters) \
+        forall_clause struct exception_name { \
+                _EHM_VTABLE_TYPE(exception_name) parameters const * virtual_table; \
+                _CLOSE
+#define _TRIVIAL_EXCEPTION_INSTANCE(exception_name, parent_name, ...) \
+        void ?{}(exception_name & this) { \
+                VTABLE_INIT(this, exception_name); \
+        } \
+        const char * _GLUE2(exception_name,_msg)(exception_name * this) { \
+                return #exception_name; \
+        } \
+        _VTABLE_INSTANCE(exception_name, parent_name,)(_GLUE2(exception_name,_msg))
+// Create a (possibly polymorphic) virtual table forward declaration.
+#define _EHM_EXTERN_VTABLE(exception_name, arguments, table_name) \
+        extern const _EHM_VTABLE_TYPE(exception_name) arguments table_name
+#define _FORALL_TRIVIAL_EXCEPTION(exception_name, parent_name, assertions, \
+                parameters, parent_parameters) \
+        _FORALL_VTABLE_DECLARATION(exception_name, parent_name, assertions, \
+                parameters, parent_parameters)(); \
+        forall assertions struct exception_name { \
+                FORALL_VTABLE_FIELD(exception_name, parameters); \
+        }; \
+        _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters)
+#define _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) \
+        forall(_UNPACK assertions | \
+                is_exception(exception_name parameters, VTABLE_TYPE(exception_name) parameters)) \
+        void ?{}(exception_name parameters & this)
+#define _FORALL_CTOR0_INSTANCE(exception_name, assertions, parameters) \
+        _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters) { \
+                (this).virtual_table = &get_exception_vtable(&this); \
+// Create a (possibly polymorphic) virtual table definition.
+#define _EHM_VIRTUAL_TABLE(exception_type, arguments, table_name) \
+        const _EHM_VTABLE_TYPE(exception_type) arguments table_name @= { \
+                .__cfavir_typeid : &_EHM_TYPE_ID_NAME(exception_type), \
+                .size : sizeof(struct exception_type arguments), \
+                .copy : copy, \
+                .^?{} : ^?{}, \
+                .msg : msg, \
+        }
+#define _DATA_EXCEPTION(exception_name, parent_name, ...) \
+        _VTABLE_DECLARATION(exception_name, parent_name)(); \
+        struct exception_name { \
+                VTABLE_FIELD(exception_name); \
+                _CLOSE
+// Create a (possibly polymorphic) copy function from an assignment operator.
+#define _EHM_DEFINE_FORALL_COPY(exception_name, forall_clause, parameters) \
+        forall_clause void copy(exception_name parameters * this, \
+                        exception_name parameters * that) { \
+                *this = *that; \
+        }
+#define _FORALL_DATA_EXCEPTION(exception_name, parent_name, \
+                assertions, parameters, parent_parameters) \
+        _FORALL_VTABLE_DECLARATION(exception_name, parent_name, \
+                assertions, parameters, parent_parameters)(); \
+        _FORALL_CTOR0_DECLARATION(exception_name, assertions, parameters); \
+        forall assertions struct exception_name { \
+                FORALL_VTABLE_FIELD(exception_name, parameters); \
+                _CLOSE
+#define _EHM_DEFINE_COPY(exception_name, arguments) \
+        void copy(exception_name arguments * this, exception_name arguments * that) { \
+                *this = *that; \
+        }
+#define _VTABLE_DECLARATION(exception_name, parent_name, ...) \
+        struct exception_name; \
+        VTABLE_TYPE(exception_name); \
+        VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *); \
+        extern VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name); \
+        VTABLE_TYPE(exception_name) { \
+                VTABLE_TYPE(parent_name) const * parent; \
+                size_t size; \
+                void (*copy)(exception_name * this, exception_name * other); \
+                void (*^?{})(exception_name & this); \
+                const char * (*msg)(exception_name * this); \
+                _CLOSE
+// Create a (possibly polymorphic) msg function
+#define _EHM_DEFINE_FORALL_MSG(exception_name, forall_clause, parameters) \
+        forall_clause const char * msg(exception_name parameters * this) { \
+                return #exception_name #parameters; \
+        }
+#define _VTABLE_INSTANCE(exception_name, parent_name, ...) \
+        VTABLE_TYPE(exception_name) const & get_exception_vtable(exception_name *) { \
+                return VTABLE_NAME(exception_name); \
+        } \
+        void _GLUE2(exception_name,_copy)(exception_name * this, exception_name * other) { \
+                *this = *other; \
+        } \
+        VTABLE_TYPE(exception_name) VTABLE_NAME(exception_name) @= { \
+                &VTABLE_NAME(parent_name), sizeof(exception_name), \
+                _GLUE2(exception_name,_copy), ^?{}, \
+                _CLOSE
+#define _EHM_DEFINE_MSG(exception_name, arguments) \
+        const char * msg(exception_name arguments * this) { \
+                return #exception_name #arguments; \
+        }
+#define _FORALL_VTABLE_DECLARATION(exception_name, parent_name, assertions, \
+                parameters, parent_parameters) \
+        forall assertions struct exception_name; \
+        forall assertions VTABLE_TYPE(exception_name) { \
+                VTABLE_TYPE(parent_name) parent_parameters const * parent; \
+// Produces the C compatable name of the virtual table type for a virtual type.
+#define _EHM_VTABLE_TYPE(type_name) struct _GLUE2(type_name,_vtable)
+// Create the vtable type for exception name.
+#define _EHM_VIRTUAL_TABLE_STRUCT(exception_name, forall_clause, parameters) \
+        forall_clause struct exception_name; \
+        forall_clause _EHM_VTABLE_TYPE(exception_name) { \
+                _EHM_TYPE_ID_TYPE(exception_name) parameters const * __cfavir_typeid; \
                 size_t size; \
                 void (*copy)(exception_name parameters * this, exception_name parameters * other); \
                 void (*^?{})(exception_name parameters & this); \
                 const char * (*msg)(exception_name parameters * this); \
                 _CLOSE
+        }
+#define _POLY_VTABLE_INSTANCE(exception_name, parent_name, ...) \
+        extern VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name); \
+        VTABLE_TYPE(exception_name)(__VA_ARGS__) const & get_exception_vtable( \
+                        exception_name(__VA_ARGS__) *) { \
+                return VTABLE_NAME(exception_name); \
+        } \
+        void _GLUE2(exception_name,_copy)( \
+                        exception_name(__VA_ARGS__) * this, exception_name(__VA_ARGS__) * other) { \
+                *this = *other; \
+        } \
+        VTABLE_TYPE(exception_name)(__VA_ARGS__) VTABLE_NAME(exception_name) @= { \
+                &VTABLE_NAME(parent_name), sizeof(exception_name(__VA_ARGS__)), \
+                _GLUE2(exception_name,_copy), ^?{}, \
+                _CLOSE
+// Define the function required to satify the trait for exceptions.
+#define _EHM_TRAIT_FUNCTION(exception_name, forall_clause, parameters) \
+        forall_clause inline void mark_exception( \
+                exception_name parameters const &, \
+                _EHM_VTABLE_TYPE(exception_name) parameters const &) {} \
+#define __EHM_TRAIT_FUNCTION(exception_name, forall_clause, parameters) \
+        forall_clause inline _EHM_VTABLE_TYPE(exception_name) parameters const & \
+                        get_exception_vtable(exception_name parameters const & this) { \
+                /* This comes before the structure definition, but we know the offset. */ \
+                /* return (_EHM_VTABLE_TYPE(exception_name) parameters const &)this; */ \
+                assert(false); \
+        }
+// Generates a new type-id structure. This is used to mangle the name of the
+// type-id instance so it also includes polymorphic information. Must be the
+// direct decendent of exception_t.
+// The second field is used to recover type information about the exception.
+#define _EHM_TYPE_ID_STRUCT(exception_name, forall_clause) \
+        forall_clause _EHM_TYPE_ID_TYPE(exception_name) { \
+                __cfa__parent_vtable const * parent; \
+        }
+// Generate a new type-id value.
+#define _EHM_TYPE_ID_VALUE(exception_name, arguments) \
+        __attribute__(( section(".gnu.linkonce." "__cfatid_" #exception_name) )) \
+        _EHM_TYPE_ID_TYPE(exception_name) arguments const \
+                        _EHM_TYPE_ID_NAME(exception_name) = { \
+                &__cfatid_exception_t, \
+        }
+// _EHM_TYPE_ID_STRUCT and _EHM_TYPE_ID_VALUE are the two that would need to
+// be updated to extend the hierarchy if we are still using macros when that
+// is added.
+// Produce the C compatable name of the type-id type for an exception type.
+#define _EHM_TYPE_ID_TYPE(exception_name) \
+        struct _GLUE2(__cfatid_struct_, exception_name)
+// Produce the name of the instance of the type-id for an exception type.
+#define _EHM_TYPE_ID_NAME(exception_name) _GLUE2(__cfatid_,exception_name)
 #define _IS_EXCEPTION(kind, exception_name, parameters, ...) \
+        kind(exception_name parameters, VTABLE_TYPE(exception_name) parameters)
+        kind(exception_name parameters, _EHM_VTABLE_TYPE(exception_name) parameters)
+// Internal helper macros:
+#define _CLOSE(...) __VA_ARGS__ }
+#define _GLUE2(left, right) left##right

libcfa/src/fstream.cfa

-              rfeacef9
+              r5407cdc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jun 19 16:24:54 2020
 // Update Count     : 384
 //
 #include "fstream.hfa"
+// Last Modified On : Tue Apr 27 22:08:57 2021
+// Update Count     : 442
+//
+#include "fstream.hfa"                                                                  // also includes iostream.hfa
 #include <stdio.h>                                                                              // vfprintf, vfscanf
 #include <stdlib.h>                                                                             // exit
 #include <stdarg.h>                                                                             // varargs
+#include <string.h>                                                                             // strlen
+#include <float.h>                                                                              // DBL_DIG, LDBL_DIG
+#include <complex.h>                                                                    // creal, cimag
+#include <string.h>                                                                             // strncpy, strerror
 #include <assert.h>
 #include <errno.h>                                                                              // errno
 // *********************************** ofstream ***********************************
 …
 void ?{}( ofstream & os, void * file ) {
+        os.$file = file;
+        os.$sepDefault = true;
+        os.$sepOnOff = false;
+        os.$nlOnOff = true;
+        os.$prt = false;
+        os.$sawNL = false;
+        $sepSetCur( os, sepGet( os ) );
+        os.file$ = file;
+        os.sepDefault$ = true;
+        os.sepOnOff$ = false;
+        os.nlOnOff$ = true;
+        os.prt$ = false;
+        os.sawNL$ = false;
+        os.acquired$ = false;
+        sepSetCur$( os, sepGet( os ) );
         sepSet( os, " " );
         sepSetTuple( os, ", " );
 …
 // private
 bool $sepPrt( ofstream & os ) { $setNL( os, false ); return os.$sepOnOff; }
 void $sepReset( ofstream & os ) { os.$sepOnOff = os.$sepDefault; }
 void $sepReset( ofstream & os, bool reset ) { os.$sepDefault = reset; os.$sepOnOff = os.$sepDefault; }
 const char * $sepGetCur( ofstream & os ) { return os.$sepCur; }
 void $sepSetCur( ofstream & os, const char sepCur[] ) { os.$sepCur = sepCur; }
 bool $getNL( ofstream & os ) { return os.$sawNL; }
 void $setNL( ofstream & os, bool state ) { os.$sawNL = state; }
 bool $getANL( ofstream & os ) { return os.$nlOnOff; }
 bool $getPrt( ofstream & os ) { return os.$prt; }
 void $setPrt( ofstream & os, bool state ) { os.$prt = state; }
+bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+bool getNL$( ofstream & os ) { return os.sawNL$; }
+void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+bool getPrt$( ofstream & os ) { return os.prt$; }
+void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
 // public
 void ?{}( ofstream & os ) { os.$file = 0p; }
+void ?{}( ofstream & os ) { os.file$ = 0p; }
 void ?{}( ofstream & os, const char name[], const char mode[] ) {
 …
 } // ^?{}
 void sepOn( ofstream & os ) { os.$sepOnOff = ! $getNL( os ); }
 void sepOff( ofstream & os ) { os.$sepOnOff = false; }
+void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
+void sepOff( ofstream & os ) { os.sepOnOff$ = false; }
 bool sepDisable( ofstream & os ) {
         bool temp = os.$sepDefault;
         os.$sepDefault = false;
         $sepReset( os );
+        bool temp = os.sepDefault$;
+        os.sepDefault$ = false;
+        sepReset$( os );
         return temp;
 } // sepDisable
 bool sepEnable( ofstream & os ) {
         bool temp = os.$sepDefault;
         os.$sepDefault = true;
         if ( os.$sepOnOff ) $sepReset( os );                            // start of line ?
+        bool temp = os.sepDefault$;
+        os.sepDefault$ = true;
+        if ( os.sepOnOff$ ) sepReset$( os );                            // start of line ?
         return temp;
 } // sepEnable
 void nlOn( ofstream & os ) { os.$nlOnOff = true; }
 void nlOff( ofstream & os ) { os.$nlOnOff = false; }
 const char * sepGet( ofstream & os ) { return os.$separator; }
+void nlOn( ofstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ofstream & os ) { os.nlOnOff$ = false; }
+const char * sepGet( ofstream & os ) { return os.separator$; }
 void sepSet( ofstream & os, const char s[] ) {
         assert( s );
         strncpy( os.$separator, s, sepSize - 1 );
         os.$separator[sepSize - 1] = '\0';
+        strncpy( os.separator$, s, ofstream_sepSize - 1 );
+        os.separator$[ofstream_sepSize - 1] = '\0';
 } // sepSet
 const char * sepGetTuple( ofstream & os ) { return os.$tupleSeparator; }
+const char * sepGetTuple( ofstream & os ) { return os.tupleSeparator$; }
 void sepSetTuple( ofstream & os, const char s[] ) {
         assert( s );
         strncpy( os.$tupleSeparator, s, sepSize - 1 );
         os.$tupleSeparator[sepSize - 1] = '\0';
+        strncpy( os.tupleSeparator$, s, ofstream_sepSize - 1 );
+        os.tupleSeparator$[ofstream_sepSize - 1] = '\0';
 } // sepSet
 void ends( ofstream & os ) {
         if ( $getANL( os ) ) nl( os );
         else $setPrt( os, false );                                                      // turn off
+        if ( getANL$( os ) ) nl( os );
+        else setPrt$( os, false );                                                      // turn off
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
+        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
 } // ends
 int fail( ofstream & os ) {
         return os.$file == 0 || ferror( (FILE *)(os.$file) );
+bool fail( ofstream & os ) {
+        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
 } // fail
 int flush( ofstream & os ) {
         return fflush( (FILE *)(os.$file) );
+        return fflush( (FILE *)(os.file$) );
 } // flush
 …
 void close( ofstream & os ) {
   if ( (FILE *)(os.$file) == 0p ) return;
   if ( (FILE *)(os.$file) == (FILE *)stdout || (FILE *)(os.$file) == (FILE *)stderr ) return;
         if ( fclose( (FILE *)(os.$file) ) == EOF ) {
+  if ( (FILE *)(os.file$) == 0p ) return;
+  if ( (FILE *)(os.file$) == (FILE *)stdout || (FILE *)(os.file$) == (FILE *)stderr ) return;
+        if ( fclose( (FILE *)(os.file$) ) == EOF ) {
                 abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
         os.$file = 0p;
+        os.file$ = 0p;
 } // close
 …
         } // if
         if ( fwrite( data, 1, size, (FILE *)(os.$file) ) != size ) {
+        if ( fwrite( data, 1, size, (FILE *)(os.file$) ) != size ) {
                 abort | IO_MSG "write" | nl | strerror( errno );
         } // if
 …
         va_list args;
         va_start( args, format );
         int len = vfprintf( (FILE *)(os.$file), format, args );
+        int len = vfprintf( (FILE *)(os.file$), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.$file) ) ) {
+                if ( ferror( (FILE *)(os.file$) ) ) {
                         abort | IO_MSG "invalid write";
                 } // if
 …
         va_end( args );
         $setPrt( os, true );                                                            // called in output cascade
         $sepReset( os );                                                                        // reset separator
+        setPrt$( os, true );                                                            // called in output cascade
+        sepReset$( os );                                                                        // reset separator
         return len;
 } // fmt
+inline void acquire( ofstream & os ) {
+        lock( os.lock$ );
+        if ( ! os.acquired$ ) os.acquired$ = true;
+        else unlock( os.lock$ );
+} // acquire
+inline void release( ofstream & os ) {
+        unlock( os.lock$ );
+} // release
+void ?{}( osacquire & acq, ofstream & os ) { &acq.os = &os; lock( os.lock$ ); }
+void ^?{}( osacquire & acq ) { release( acq.os ); }
 static ofstream soutFile = { (FILE *)stdout };
 …
 ofstream & serr = serrFile, & stderr = serrFile;
+static ofstream lsoutFile = { (FILE *)stdout };
+ofstream & lsout = lsoutFile;
 static ofstream exitFile = { (FILE *)stdout };
 ofstream & exit = exitFile;
 …
 ofstream & abort = abortFile;
+ofstream & nl( ofstream & os ) {
+        nl$( os );                                                                                      // call basic_ostream nl
+        flush( os );
+        return os;
+        // (ofstream &)(os | '\n');
+        // setPrt$( os, false );                                                        // turn off
+        // setNL$( os, true );
+        // flush( os );
+        // return sepOff( os );                                                 // prepare for next line
+} // nl
 // *********************************** ifstream ***********************************
 …
 // private
 void ?{}( ifstream & is, void * file ) {
+        is.$file = file;
+        is.$nlOnOff = false;
+        is.file$ = file;
+        is.nlOnOff$ = false;
+        is.acquired$ = false;
 } // ?{}
 // public
 void ?{}( ifstream & is ) { is.$file = 0p; }
+void ?{}( ifstream & is ) { is.file$ = 0p; }
 void ?{}( ifstream & is, const char name[], const char mode[] ) {
 …
 } // ^?{}
 void nlOn( ifstream & os ) { os.$nlOnOff = true; }
 void nlOff( ifstream & os ) { os.$nlOnOff = false; }
 bool getANL( ifstream & os ) { return os.$nlOnOff; }
 int fail( ifstream & is ) {
         return is.$file == 0p || ferror( (FILE *)(is.$file) );
+void nlOn( ifstream & os ) { os.nlOnOff$ = true; }
+void nlOff( ifstream & os ) { os.nlOnOff$ = false; }
+bool getANL( ifstream & os ) { return os.nlOnOff$; }
+bool fail( ifstream & is ) {
+        return is.file$ == 0p || ferror( (FILE *)(is.file$) );
 } // fail
+void ends( ifstream & is ) {
+        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
+} // ends
 int eof( ifstream & is ) {
         return feof( (FILE *)(is.$file) );
+        return feof( (FILE *)(is.file$) );
 } // eof
 …
         } // if
         #endif // __CFA_DEBUG__
         is.$file = file;
+        is.file$ = file;
 } // open
 …
 void close( ifstream & is ) {
   if ( (FILE *)(is.$file) == 0p ) return;
   if ( (FILE *)(is.$file) == (FILE *)stdin ) return;
         if ( fclose( (FILE *)(is.$file) ) == EOF ) {
+  if ( (FILE *)(is.file$) == 0p ) return;
+  if ( (FILE *)(is.file$) == (FILE *)stdin ) return;
+        if ( fclose( (FILE *)(is.file$) ) == EOF ) {
                 abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
         is.$file = 0p;
+        is.file$ = 0p;
 } // close
 …
         } // if
         if ( fread( data, size, 1, (FILE *)(is.$file) ) == 0 ) {
+        if ( fread( data, size, 1, (FILE *)(is.file$) ) == 0 ) {
                 abort | IO_MSG "read" | nl | strerror( errno );
         } // if
 …
         } // if
         if ( ungetc( c, (FILE *)(is.$file) ) == EOF ) {
+        if ( ungetc( c, (FILE *)(is.file$) ) == EOF ) {
                 abort | IO_MSG "ungetc" | nl | strerror( errno );
         } // if
 …
         va_start( args, format );
         int len = vfscanf( (FILE *)(is.$file), format, args );
+        int len = vfscanf( (FILE *)(is.file$), format, args );
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.$file) ) ) {
+                if ( ferror( (FILE *)(is.file$) ) ) {
                         abort | IO_MSG "invalid read";
                 } // if
 …
 } // fmt
+inline void acquire( ifstream & is ) {
+        lock( is.lock$ );
+        if ( ! is.acquired$ ) is.acquired$ = true;
+        else unlock( is.lock$ );
+} // acquire
+inline void release( ifstream & is ) {
+        unlock( is.lock$ );
+} // release
+void ?{}( isacquire & acq, ifstream & is ) { &acq.is = &is; lock( is.lock$ ); }
+void ^?{}( isacquire & acq ) { release( acq.is ); }
 static ifstream sinFile = { (FILE *)stdin };
 ifstream & sin = sinFile, & stdin = sinFile;
 …
+EHM_VIRTUAL_TABLE(Open_Failure, Open_Failure_main_table);
 void ?{}( Open_Failure & this, ofstream & ostream ) {
         VTABLE_INIT(this, Open_Failure);
+        this.virtual_table = &Open_Failure_main_table;
         this.ostream = &ostream;
         this.tag = 1;
+}
 void ?{}( Open_Failure & this, ifstream & istream ) {
         VTABLE_INIT(this, Open_Failure);
+        this.virtual_table = &Open_Failure_main_table;
         this.istream = &istream;
         this.tag = 0;
+}
-const char * Open_Failure_msg(Open_Failure * this) {
-        return "Open_Failure";
+}
-VTABLE_INSTANCE(Open_Failure)(Open_Failure_msg);
 void throwOpen_Failure( ofstream & ostream ) {
         Open_Failure exc = { ostream };

libcfa/src/fstream.hfa

-              rfeacef9
+              r5407cdc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jun 19 16:29:17 2020
 // Update Count     : 189
+// Last Modified On : Tue Apr 27 22:00:30 2021
+// Update Count     : 226
 //
 #pragma once
 #include "bits/weakso_locks.hfa"
+#include "bits/weakso_locks.hfa"                                                // mutex_lock
 #include "iostream.hfa"
 #include <exception.hfa>
 …
 enum { sepSize = 16 };
+enum { ofstream_sepSize = 16 };
 struct ofstream {
+        void * $file;
+        bool $sepDefault;
+        bool $sepOnOff;
+        bool $nlOnOff;
+        bool $prt;                                                                                      // print text
+        bool $sawNL;
+        const char * $sepCur;
+        char $separator[sepSize];
+        char $tupleSeparator[sepSize];
+//      multiple_acquisition_lock lock;
+        void * file$;
+        bool sepDefault$;
+        bool sepOnOff$;
+        bool nlOnOff$;
+        bool prt$;                                                                                      // print text
+        bool sawNL$;
+        const char * sepCur$;
+        char separator$[ofstream_sepSize];
+        char tupleSeparator$[ofstream_sepSize];
+        multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ofstream
+// Satisfies ostream
 // private
 bool $sepPrt( ofstream & );
 void $sepReset( ofstream & );
 void $sepReset( ofstream &, bool );
 const char * $sepGetCur( ofstream & );
 void $sepSetCur( ofstream &, const char [] );
 bool $getNL( ofstream & );
 void $setNL( ofstream &, bool );
 bool $getANL( ofstream & );
 bool $getPrt( ofstream & );
 void $setPrt( ofstream &, bool );
+bool sepPrt$( ofstream & );
+void sepReset$( ofstream & );
+void sepReset$( ofstream &, bool );
+const char * sepGetCur$( ofstream & );
+void sepSetCur$( ofstream &, const char [] );
+bool getNL$( ofstream & );
+void setNL$( ofstream &, bool );
+bool getANL$( ofstream & );
+bool getPrt$( ofstream & );
+void setPrt$( ofstream &, bool );
 // public
 …
 void sepSetTuple( ofstream &, const char [] );
+void ends( ofstream & os );
+int fail( ofstream & );
+void ends( ofstream & );
+int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
+bool fail( ofstream & );
 int flush( ofstream & );
 void open( ofstream &, const char name[], const char mode[] );
+void open( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w"
 void open( ofstream &, const char name[] );
 void close( ofstream & );
 ofstream & write( ofstream &, const char data[], size_t size );
-int fmt( ofstream &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
+void ?{}( ofstream & os );
+void ?{}( ofstream & os, const char name[], const char mode[] );
+void ?{}( ofstream & os, const char name[] );
+void ^?{}( ofstream & os );
+void acquire( ofstream & );
+void release( ofstream & );
+struct osacquire {
+        ofstream & os;
+};
+void ?{}( osacquire & acq, ofstream & );
+void ^?{}( osacquire & acq );
+void ?{}( ofstream & );
+void ?{}( ofstream &, const char name[], const char mode[] ); // FIX ME: use default = "w"
+void ?{}( ofstream &, const char name[] );
+void ^?{}( ofstream & );
+// private
+static inline ofstream & nl$( ofstream & os ) { return nl( os ); } // remember basic_ostream nl
+// public
+ofstream & nl( ofstream & os );                                                 // override basic_ostream nl
 extern ofstream & sout, & stdout, & serr, & stderr;             // aliases
 …
 struct ifstream {
+        void * $file;
+        bool $nlOnOff;
+        void * file$;
+        bool nlOnOff$;
+        multiple_acquisition_lock lock$;
+        bool acquired$;
 }; // ifstream
+// Satisfies istream
 // public
 …
 void nlOff( ifstream & );
 bool getANL( ifstream & );
+int fail( ifstream & is );
+void ends( ifstream & );
+int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+bool fail( ifstream & is );
 int eof( ifstream & is );
 void open( ifstream & is, const char name[], const char mode[] );
+void open( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
 void open( ifstream & is, const char name[] );
 void close( ifstream & is );
 ifstream & read( ifstream & is, char * data, size_t size );
 ifstream & ungetc( ifstream & is, char c );
+int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+void acquire( ifstream & is );
+void release( ifstream & is );
+struct isacquire {
+        ifstream & is;
+};
+void ?{}( isacquire & acq, ifstream & is );
+void ^?{}( isacquire & acq );
 void ?{}( ifstream & is );
 void ?{}( ifstream & is, const char name[], const char mode[] );
+void ?{}( ifstream & is, const char name[], const char mode[] ); // FIX ME: use default = "r"
 void ?{}( ifstream & is, const char name[] );
 void ^?{}( ifstream & is );
 …
 DATA_EXCEPTION(Open_Failure)(
+EHM_EXCEPTION(Open_Failure)(
         union {
                 ofstream * ostream;
 …
 );
 void ?{}( Open_Failure & this, ofstream & ostream );
 void ?{}( Open_Failure & this, ifstream & istream );
+void ?{}( Open_Failure & this, ofstream & );
+void ?{}( Open_Failure & this, ifstream & );
 // Local Variables: //

libcfa/src/gmp.hfa

-              rfeacef9
+              r5407cdc
 // Created On       : Tue Apr 19 08:43:43 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb  9 09:56:54 2020
 // Update Count     : 31
+// Last Modified On : Tue Apr 20 20:59:21 2021
+// Update Count     : 32
 //
 …
         forall( ostype & | ostream( ostype ) ) {
                 ostype & ?|?( ostype & os, Int mp ) {
                         if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                        if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                         gmp_printf( "%Zd", mp.mpz );
                         sepOn( os );

libcfa/src/heap.cfa

-              rfeacef9
+              r5407cdc
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jan 10 11:20:49 2021
 // Update Count     : 1031
+// Last Modified On : Tue Apr 20 21:20:48 2021
+// Update Count     : 1033
 //
 …
 static bool prtFree = false;
 inline bool prtFree() {
+bool prtFree() {
         return prtFree;
 } // prtFree
 …
         // Set the alignment for an the allocation and return previous alignment or 0 if no alignment.
         size_t $malloc_alignment_set( void * addr, size_t alignment ) {
+        size_t malloc_alignment_set$( void * addr, size_t alignment ) {
           if ( unlikely( addr == 0p ) ) return libAlign();      // minimum alignment
                 size_t ret;
 …
                 } // if
                 return ret;
         } // $malloc_alignment_set
+        } // malloc_alignment_set$
 …
         // Set allocation is zero filled and return previous zero filled.
         bool $malloc_zero_fill_set( void * addr ) {
+        bool malloc_zero_fill_set$( void * addr ) {
           if ( unlikely( addr == 0p ) ) return false;           // null allocation is not zero fill
                 HeapManager.Storage.Header * header = headerAddr( addr );
 …
                 header->kind.real.blockSize |= 2;                               // mark as zero filled
                 return ret;
         } // $malloc_zero_fill_set
+        } // malloc_zero_fill_set$
 …
         // Set allocation size and return previous size.
         size_t $malloc_size_set( void * addr, size_t size ) {
+        size_t malloc_size_set$( void * addr, size_t size ) {
           if ( unlikely( addr == 0p ) ) return 0;                       // null allocation has 0 size
                 HeapManager.Storage.Header * header = headerAddr( addr );
 …
                 header->kind.real.size = size;
                 return ret;
         } // $malloc_size_set
+        } // malloc_size_set$

libcfa/src/iostream.cfa

-              rfeacef9
+              r5407cdc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug 24 08:31:35 2020
 // Update Count     : 1130
+// Last Modified On : Tue Apr 27 18:01:03 2021
+// Update Count     : 1330
 //
 …
 forall( ostype & | ostream( ostype ) ) {
+forall( ostype & | basic_ostream( ostype ) ) {
         ostype & ?|?( ostype & os, bool b ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%s", b ? "true" : "false" );
                 return os;
 …
         ostype & ?|?( ostype & os, char c ) {
                 fmt( os, "%c", c );
                 if ( c == '\n' ) $setNL( os, true );
+                if ( c == '\n' ) setNL$( os, true );
                 return sepOff( os );
         } // ?|?
 …
         ostype & ?|?( ostype & os, signed char sc ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hhd", sc );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned char usc ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hhu", usc );
                 return os;
 …
         ostype & ?|?( ostype & os, short int si ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hd", si );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned short int usi ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%hu", usi );
                 return os;
 …
         ostype & ?|?( ostype & os, int i ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%d", i );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned int ui ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%u", ui );
                 return os;
 …
         ostype & ?|?( ostype & os, long int li ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%ld", li );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned long int uli ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%lu", uli );
                 return os;
 …
         ostype & ?|?( ostype & os, long long int lli ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%lld", lli );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned long long int ulli ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%llu", ulli );
                 return os;
 …
         } // ?|?
 #if defined( __SIZEOF_INT128__ )
+        #if defined( __SIZEOF_INT128__ )
         //      UINT64_MAX 18_446_744_073_709_551_615_ULL
         #define P10_UINT64 10_000_000_000_000_000_000_ULL       // 19 zeroes
         static inline void base10_128( ostype & os, unsigned int128 val ) {
 #if defined(__GNUC__) && __GNUC_PREREQ(7,0)                             // gcc version >= 7
+                #if defined(__GNUC__) && __GNUC_PREREQ(7,0)             // gcc version >= 7
                 if ( val > P10_UINT64 ) {
 #else
+                #else
                 if ( (uint64_t)(val >> 64) != 0 || (uint64_t)val > P10_UINT64 ) { // patch gcc 5 & 6 -O3 bug
 #endif // __GNUC_PREREQ(7,0)
+                #endif // __GNUC_PREREQ(7,0)
                         base10_128( os, val / P10_UINT64 );                     // recursive
                         fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
 …
         ostype & ?|?( ostype & os, int128 llli ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 base10_128( os, llli );
                 return os;
 …
         ostype & ?|?( ostype & os, unsigned int128 ullli ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 base10_128( os, ullli );
                 return os;
 …
                 (ostype &)(os | ullli); ends( os );
         } // ?|?
 #endif // __SIZEOF_INT128__
+        #endif // __SIZEOF_INT128__
         #define PrintWithDP( os, format, val, ... ) \
 …
                         int len = snprintf( buf, size, format, ##__VA_ARGS__, val ); \
                         fmt( os, "%s", buf ); \
                         if ( isfinite( val ) ) {                                        /* if number, always print decimal point */ \
+                        if ( isfinite( val ) ) { /* if number, print decimal point when no fraction or exponent */ \
                                 for ( int i = 0;; i += 1 ) { \
                                         if ( i == len ) { fmt( os, "." ); break; } \
                                         if ( buf[i] == '.' ) break; \
+                                        if ( buf[i] == '.' || buf[i] == 'e' || buf[i] == 'E' ) break; /* decimal point or scientific ? */ \
                                 } /* for */ \
                         } /* if */ \
 …
         ostype & ?|?( ostype & os, float f ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 PrintWithDP( os, "%g", f );
                 return os;
 …
         ostype & ?|?( ostype & os, double d ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 PrintWithDP( os, "%.*lg", d, DBL_DIG );
                 return os;
 …
         ostype & ?|?( ostype & os, long double ld ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 PrintWithDP( os, "%.*Lg", ld, LDBL_DIG );
                 return os;
 …
         ostype & ?|?( ostype & os, float _Complex fc ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              os | crealf( fc ) | nonl;
                 PrintWithDP( os, "%g", crealf( fc ) );
 …
         ostype & ?|?( ostype & os, double _Complex dc ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              os | creal( dc ) | nonl;
                 PrintWithDP( os, "%.*lg", creal( dc ), DBL_DIG );
 …
         ostype & ?|?( ostype & os, long double _Complex ldc ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
 //              os | creall( ldc ) || nonl;
                 PrintWithDP( os, "%.*Lg", creall( ldc ), LDBL_DIG );
 …
         } // ?|?
         ostype & ?|?( ostype & os, const char str[] ) {
+        ostype & ?|?( ostype & os, const char s[] ) {
                 enum { Open = 1, Close, OpenClose };
                 static const unsigned char mask[256] @= {
 …
                 }; // mask
           if ( str[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator
+          if ( s[0] == '\0' ) { sepOff( os ); return os; } // null string => no separator
                 // first character IS NOT spacing or closing punctuation => add left separator
                 unsigned char ch = str[0];                                              // must make unsigned
                 if ( $sepPrt( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
                         fmt( os, "%s", $sepGetCur( os ) );
+                unsigned char ch = s[0];                                                // must make unsigned
+                if ( sepPrt$( os ) && mask[ ch ] != Close && mask[ ch ] != OpenClose ) {
+                        fmt( os, "%s", sepGetCur$( os ) );
                 } // if
                 // if string starts line, must reset to determine open state because separator is off
                 $sepReset( os );                                                                // reset separator
+                sepReset$( os );                                                                // reset separator
                 // last character IS spacing or opening punctuation => turn off separator for next item
+                size_t len = strlen( str );
+                ch = str[len - 1];                                                              // must make unsigned
+                if ( $sepPrt( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
+                int len = strlen( s );
+                ch = s[len - 1];                                                                // must make unsigned
+                fmt( os, "%s", s );                                                             // fmt resets seperator, but reset it again
+                if ( sepPrt$( os ) && mask[ ch ] != Open && mask[ ch ] != OpenClose ) {
                         sepOn( os );
                 } else {
                         sepOff( os );
                 } // if
                 if ( ch == '\n' ) $setNL( os, true );                   // check *AFTER* $sepPrt call above as it resets NL flag
                 return write( os, str, len );
+        } // ?|?
         void ?|?( ostype & os, const char str[] ) {
                 (ostype &)(os | str); ends( os );
         } // ?|?
 //      ostype & ?|?( ostype & os, const char16_t * str ) {
 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
+                if ( ch == '\n' ) setNL$( os, true );                   // check *AFTER* sepPrt$ call above as it resets NL flag
+                return os;
+//              return write( os, s, len );
+        } // ?|?
+        void ?|?( ostype & os, const char s[] ) {
+                (ostype &)(os | s); ends( os );
+        } // ?|?
+//      ostype & ?|?( ostype & os, const char16_t * s ) {
+//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
+//              fmt( os, "%ls", s );
 //              return os;
 //      } // ?|?
 // #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
 //      ostype & ?|?( ostype & os, const char32_t * str ) {
 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
+//      ostype & ?|?( ostype & os, const char32_t * s ) {
+//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
+//              fmt( os, "%ls", s );
 //              return os;
 //      } // ?|?
 // #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
 //      ostype & ?|?( ostype & os, const wchar_t * str ) {
 //              if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
 //              fmt( os, "%ls", str );
+//      ostype & ?|?( ostype & os, const wchar_t * s ) {
+//              if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
+//              fmt( os, "%ls", s );
 //              return os;
 //      } // ?|?
         ostype & ?|?( ostype & os, const void * p ) {
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 fmt( os, "%p", p );
                 return os;
 …
         // manipulators
         ostype & ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
+                (ostype &)(manip( os ));
+                return os;
+                return manip( os );
         } // ?|?
         void ?|?( ostype & os, ostype & (* manip)( ostype & ) ) {
                 (ostype &)(manip( os ));
                 if ( $getPrt( os ) ) ends( os );                                // something printed ?
                 $setPrt( os, false );                                                   // turn off
+                manip( os );
+                if ( getPrt$( os ) ) ends( os );                                // something printed ?
+                setPrt$( os, false );                                                   // turn off
         } // ?|?
 …
         ostype & nl( ostype & os ) {
                 (ostype &)(os | '\n');
+                $setPrt( os, false );                                                   // turn off
+                $setNL( os, true );
+                flush( os );
+                setPrt$( os, false );                                                   // turn off
+                setNL$( os, true );
                 return sepOff( os );                                                    // prepare for next line
         } // nl
         ostype & nonl( ostype & os ) {
                 $setPrt( os, false );                                                   // turn off
+                setPrt$( os, false );                                                   // turn off
                 return os;
         } // nonl
 …
                 return os;
         } // nlOff
+} // distribution
+forall( ostype & | ostream( ostype ) ) {
+        ostype & acquire( ostype & os ) {
+                acquire( os );                                                                  // call void returning
+                return os;
+        } // acquire
 } // distribution
 …
         ostype & ?|?( ostype & os, T arg, Params rest ) {
                 (ostype &)(os | arg);                                                   // print first argument
                 $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
+                sepSetCur$( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
                 $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
+                sepSetCur$( os, sepGet( os ) );                                 // switch to regular separator
                 return os;
         } // ?|?
 …
                 // (ostype &)(?|?( os, arg, rest )); ends( os );
                 (ostype &)(os | arg);                                                   // print first argument
                 $sepSetCur( os, sepGetTuple( os ) );                    // switch to tuple separator
+                sepSetCur$( os, sepGetTuple( os ) );                    // switch to tuple separator
                 (ostype &)(os | rest);                                                  // print remaining arguments
                 $sepSetCur( os, sepGet( os ) );                                 // switch to regular separator
+                sepSetCur$( os, sepGet( os ) );                                 // switch to regular separator
                 ends( os );
         } // ?|?
 …
 // Default prefix for non-decimal prints is 0b, 0, 0x.
 #define IntegralFMTImpl( T, IFMTNP, IFMTP ) \
 forall( ostype & | ostream( ostype ) ) { \
+forall( ostype & | basic_ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
+\
                 if ( f.base == 'b' || f.base == 'B' ) {                 /* bespoke binary format */ \
 …
                 return os; \
         } /* ?|? */ \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
+} // distribution
+IntegralFMTImpl( signed char, "%    *hh ", "%    *.*hh " )
+IntegralFMTImpl( unsigned char, "%    *hh ", "%    *.*hh " )
+IntegralFMTImpl( signed short int, "%    *h ", "%    *.*h " )
+IntegralFMTImpl( unsigned short int, "%    *h ", "%    *.*h " )
+IntegralFMTImpl( signed int, "%    * ", "%    *.* " )
+IntegralFMTImpl( unsigned int, "%    * ", "%    *.* " )
+IntegralFMTImpl( signed long int, "%    *l ", "%    *.*l " )
+IntegralFMTImpl( unsigned long int, "%    *l ", "%    *.*l " )
+IntegralFMTImpl( signed long long int, "%    *ll ", "%    *.*ll " )
+IntegralFMTImpl( unsigned long long int, "%    *ll ", "%    *.*ll " )
+#if 0
+        void ?|?( ostype & os, _Ostream_Manip(T) f ) { \
+                (ostype &)(os | f); ends( os ); \
+        } /* ?|? */ \
+} // distribution
+IntegralFMTImpl( signed char, "     *hh ", "     *.*hh " )
+IntegralFMTImpl( unsigned char, "     *hh ", "     *.*hh " )
+IntegralFMTImpl( signed short int, "     *h ", "     *.*h " )
+IntegralFMTImpl( unsigned short int, "     *h ", "     *.*h " )
+IntegralFMTImpl( signed int, "     * ", "     *.* " )
+IntegralFMTImpl( unsigned int, "     * ", "     *.* " )
+IntegralFMTImpl( signed long int, "     *l ", "     *.*l " )
+IntegralFMTImpl( unsigned long int, "     *l ", "     *.*l " )
+IntegralFMTImpl( signed long long int, "     *ll ", "     *.*ll " )
+IntegralFMTImpl( unsigned long long int, "     *ll ", "     *.*ll " )
 #if defined( __SIZEOF_INT128__ )
 // Default prefix for non-decimal prints is 0b, 0, 0x.
+#define IntegralFMTImpl128( T, SIGNED, CODE, IFMTNP, IFMTP ) \
+forall( ostype & | ostream( ostype ) ) \
+static void base10_128( ostype & os, _Ostream_Manip(T) f ) { \
+        if ( f.val > UINT64_MAX ) { \
+                unsigned long long int lsig = f.val % P10_UINT64; \
+                f.val /= P10_UINT64; /* msig */ \
+                base10_128( os, f ); /* recursion */ \
+                _Ostream_Manip(unsigned long long int) fmt @= { lsig, 0, 19, 'u', { .all : 0 } }; \
+                fmt.flags.nobsdp = true; \
+                /* printf( "fmt1 %c %lld %d\n", fmt.base, fmt.val, fmt.all ); */ \
+                sepOff( os ); \
+                (ostype &)(os | fmt); \
+        } else { \
+                /* printf( "fmt2 %c %lld %d\n", f.base, (unsigned long long int)f.val, f.all ); */ \
+                _Ostream_Manip(SIGNED long long int) fmt @= { (SIGNED long long int)f.val, f.wd, f.pc, f.base, { .all : f.all } }; \
+                (ostype &)(os | fmt); \
+        } /* if */ \
+} /* base10_128 */ \
+forall( ostype & | ostream( ostype ) ) { \
+        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+\
+                if ( f.base == 'b' | f.base == 'B' | f.base == 'o' | f.base == 'x' | f.base == 'X' ) { \
+                        unsigned long long int msig = (unsigned long long int)(f.val >> 64); \
+                        unsigned long long int lsig = (unsigned long long int)(f.val); \
+                        _Ostream_Manip(SIGNED long long int) fmt @= { msig, f.wd, f.pc, f.base, { .all : f.all } }; \
+                        _Ostream_Manip(unsigned long long int) fmt2 @= { lsig, 0, 0, f.base, { .all : 0 } }; \
+                        if ( msig == 0 ) { \
+                                fmt.val = lsig; \
+                                (ostype &)(os | fmt); \
+                        } else { \
+                                fmt2.flags.pad0 = fmt2.flags.nobsdp = true;     \
+                                if ( f.base == 'b' | f.base == 'B' ) { \
+                                        if ( fmt.flags.pc && fmt.pc > 64 ) fmt.pc -= 64; else { fmt.flags.pc = false; fmt.pc = 0; } \
+                                        if ( fmt.flags.left ) { \
+                                                fmt.flags.left = false; \
+                                                fmt.wd = 0; \
+                                                /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.flags.left = true; \
+                                                int msigd = high1( msig ); \
+                                                fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+                                                if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0b base specifier */ \
+                                                if ( (int)fmt2.wd < 64 ) fmt2.wd = 64; /* cast deals with negative value */ \
+                                                fmt2.flags.pc = true; fmt2.pc = 64; \
+                                        } else { \
+                                                if ( fmt.wd > 64 ) fmt.wd -= 64; \
+                                                else fmt.wd = 1; \
+                                                /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.wd = 64; \
+                                        } /* if */ \
+                                        /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } else if ( f.base == 'o' ) { \
+                                        if ( fmt.flags.pc && fmt.pc > 22 ) fmt.pc -= 22; else { fmt.flags.pc = false; fmt.pc = 0; } \
+                                        fmt.val = (unsigned long long int)fmt.val >> 2; \
+                                        fmt2.val = ((msig & 0x3) << 1) + ((lsig & 0x8000000000000000U) != 0); \
+                                        if ( fmt.flags.left ) { \
+                                                fmt.flags.left = false; \
+                                                fmt.wd = 0; \
+                                                /* printf( "L %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+                                                (ostype &)(os | fmt | "" | fmt2); \
+                                                sepOff( os ); \
+                                                fmt2.flags.left = true; \
+                                                int msigd = ceiling_div( high1( fmt.val ), 3 ); \
+                                                fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+                                                if ( ! fmt.flags.nobsdp ) fmt2.wd -= 1; /* compensate for 0 base specifier */ \
+                                                if ( (int)fmt2.wd < 21 ) fmt2.wd = 21; /* cast deals with negative value */ \
+                                                fmt2.flags.pc = true; fmt2.pc = 21; \
+                                        } else { \
+                                                if ( fmt.wd > 22 ) fmt.wd -= 22; \
+                                                else fmt.wd = 1; \
+                                                /* printf( "R %llo %llo %llo %d %d '%c' %x %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all, fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+                                                (ostype &)(os | fmt | "" | fmt2); \
+                                                sepOff( os ); \
+                                                fmt2.wd = 21; \
+                                        } /* if */ \
+                                        fmt2.val = lsig & 0x7fffffffffffffffU; \
+                                        /* printf( "\nC %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+                                        (ostype &)(os | fmt2); \
+                                } else { /* f.base == 'x'  | f.base == 'X' */ \
+                                        if ( fmt.flags.pc && fmt.pc > 16 ) fmt.pc -= 16; else { fmt.flags.pc = false; fmt.pc = 0; } \
+                                        if ( fmt.flags.left ) { \
+                                                fmt.flags.left = false; \
+                                                fmt.wd = 0; \
+                                                /* printf( "L %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.flags.left = true; \
+                                                int msigd = high1( msig ); \
+                                                fmt2.wd = f.wd - (fmt.pc > msigd ? fmt.pc : msigd); \
+                                                if ( ! fmt.flags.nobsdp ) fmt2.wd -= 2; /* compensate for 0x base specifier */ \
+                                                if ( (int)fmt2.wd < 16 ) fmt2.wd = 16; /* cast deals with negative value */ \
+                                                fmt2.flags.pc = true; fmt2.pc = 16; \
+                                        } else { \
+                                                if ( fmt.wd > 16 ) fmt.wd -= 16; \
+                                                else fmt.wd = 1; \
+                                                /* printf( "R %llo %llo %llo %d %d '%c' %x\n", msig, lsig, fmt.val, fmt.wd, fmt.pc, fmt.base, fmt.all ); */ \
+                                                fmt2.wd = 16; \
+                                        } /* if */ \
+                                        /* printf( "C %llo %d %d '%c' %x\n", fmt2.val, fmt2.wd, fmt2.pc, fmt2.base, fmt2.all ); */ \
+                                        (ostype &)(os | fmt | "" | fmt2); \
+                                } /* if */ \
+                        } /* if */ \
+                } else { \
+                        if ( CODE == 'd' ) { \
+                                if ( f.val < 0 )  { fmt( os, "-" ); sepOff( os ); f.val = -f.val; f.flags.sign = false; } \
+                        } /* if */ \
+                        base10_128( os, f ); \
+                } /* if */ \
+                return os; \
+        } /* ?|? */ \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
+} // distribution
+IntegralFMTImpl128( int128, signed, 'd', "%    *ll ", "%    *.*ll " )
+IntegralFMTImpl128( unsigned int128, unsigned, 'u', "%    *ll ", "%    *.*ll " )
+#endif // __SIZEOF_INT128__
+#endif // 0
+#if 1
+#if defined( __SIZEOF_INT128__ )
+// Default prefix for non-decimal prints is 0b, 0, 0x.
+forall( ostype & | ostream( ostype ) )
+forall( ostype & | basic_ostream( ostype ) )
 static inline void base_128( ostype & os, unsigned int128 val, unsigned int128 power, _Ostream_Manip(uint64_t) & f, unsigned int maxdig, unsigned int bits, unsigned int cnt = 0 ) {
         int wd = 1;                                                                                     // f.wd is never 0 because 0 implies left-pad
 …
 #define IntegralFMTImpl128( T ) \
 forall( ostype & | ostream( ostype ) ) { \
+forall( ostype & | basic_ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
                 _Ostream_Manip(uint64_t) fmt; \
 …
 IntegralFMTImpl128( unsigned int128 )
 #endif // __SIZEOF_INT128__
-#endif // 0
 // *********************************** floating point ***********************************
+#define PrintWithDP2( os, format, val, ... ) \
+static const char *suffixes[] = {
+        "y", "z", "a", "f", "p", "n", "u", "m", "",
+        "K", "M", "G", "T", "P", "E", "Z", "Y"
+};
+#define SUFFIXES_START (-24) /* Smallest power for which there is a suffix defined. */
+#define SUFFIXES_END (SUFFIXES_START + (int)((sizeof(suffixes) / sizeof(char *) - 1) * 3))
+#define PrintWithDP2( os, format, ... ) \
         { \
                 enum { size = 48 }; \
                 char buf[size]; \
                 int bufbeg = 0, i, len = snprintf( buf, size, format, ##__VA_ARGS__, val ); \
                 if ( isfinite( val ) && (f.base != 'g' || f.pc != 0) ) { /* if number, print decimal point */ \
                         for ( i = 0; i < len && buf[i] != '.' && buf[i] != 'e' && buf[i] != 'E'; i += 1 ); /* decimal point or scientific ? */ \
                         if ( i == len && ! f.flags.nobsdp ) { \
                                 if ( ! f.flags.left ) { \
                                         buf[i] = '.'; buf[i + 1] = '\0'; \
                                         if ( buf[0] == ' ' ) bufbeg = 1;        /* decimal point within width */ \
                                 } else { \
                                         for ( i = 0; i < len && buf[i] != ' '; i += 1 ); /* trailing blank ? */ \
                                         buf[i] = '.'; \
                                         if ( i == len ) buf[i + 1] = '\0'; \
+                if ( ! f.flags.eng ) { \
+                        len = snprintf( buf, size, format, ##__VA_ARGS__ ); \
+                        if ( isfinite( f.val ) && ( f.pc != 0 || ! f.flags.nobsdp ) ) { /* if number, print decimal point when no fraction or exponent */ \
+                                for ( i = 0; i < len && buf[i] != '.' && buf[i] != 'e' && buf[i] != 'E'; i += 1 ); /* decimal point or scientific ? */ \
+                                if ( i == len ) { \
+                                        if ( ! f.flags.left ) { \
+                                                buf[i] = '.'; buf[i + 1] = '\0'; \
+                                                if ( buf[0] == ' ' ) bufbeg = 1; /* decimal point within width */ \
+                                        } else { \
+                                                for ( i = 0; i < len && buf[i] != ' '; i += 1 ); /* trailing blank ? */ \
+                                                buf[i] = '.'; \
+                                                if ( i == len ) buf[i + 1] = '\0'; \
+                                        } /* if */ \
                                 } /* if */ \
                         } /* if */ \
+                } else { \
+                        int exp10, len2; \
+                        eng( f.val, f.pc, exp10 );                                      /* changes arguments */ \
+                        if ( ! f.flags.left && f.wd > 1 ) { \
+                                /* Exponent size (number of digits, 'e', optional minus sign) */ \
+                                f.wd -= lrint( floor( log10( abs( exp10 ) ) ) ) + 1 + 1 + (exp10 < 0 ? 1 : 0); \
+                                if ( f.wd < 1 ) f.wd = 1; \
+                        } /* if */ \
+                        len = snprintf( buf, size, format, ##__VA_ARGS__ ); \
+                        if ( f.flags.left ) { \
+                                for ( len -= 1; len > 0 && buf[len] == ' '; len -= 1 ); \
+                                len += 1; \
+                        } /* if */ \
+                        if ( ! f.flags.nobsdp || (exp10 < SUFFIXES_START) || (exp10 > SUFFIXES_END) ) { \
+                                len2 = snprintf( &buf[len], size - len, "e%d", exp10 ); \
+                        } else { \
+                                len2 = snprintf( &buf[len], size - len, "%s", suffixes[(exp10 - SUFFIXES_START) / 3] ); \
+                        } /* if */ \
+                        if ( f.flags.left && len + len2 < f.wd ) buf[len + len2] = ' '; \
                 } /* if */ \
                 fmt( os, "%s", &buf[bufbeg] ); \
 …
 #define FloatingPointFMTImpl( T, DFMTNP, DFMTP ) \
+forall( ostype & | ostream( ostype ) ) { \
+forall( ostype & | basic_ostream( ostype ) ) { \
+        static void eng( T &value, int & pc, int & exp10 ) { \
+                exp10 = lrint( floor( log10( abs( value ) ) ) ); /* round to desired precision */ \
+                if ( exp10 < 0 ) exp10 -= 2; \
+                exp10 = floor( exp10, 3 ); \
+                value *= pow( 10.0, -exp10 ); \
+                if ( pc <= 3 ) pc = 3; \
+        } /* eng */ \
+\
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
+                if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) ); \
+                char fmtstr[sizeof(DFMTP)];                                             /* sizeof includes '\0' */ \
+                enum { size = 48 }; \
+                char buf[size]; \
+                int bufbeg = 0, i, len; \
+\
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) ); \
+                char fmtstr[sizeof(DFMTP) + 8];                                 /* sizeof includes '\0' */ \
                 if ( ! f.flags.pc ) memcpy( &fmtstr, DFMTNP, sizeof(DFMTNP) ); \
                 else memcpy( &fmtstr, DFMTP, sizeof(DFMTP) ); \
 …
                         fmtstr[sizeof(DFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
                         /* printf( "%g %d %s\n", f.val, f.wd, &fmtstr[star]); */ \
                         PrintWithDP2( os, &fmtstr[star], f.val, f.wd ) \
+                        PrintWithDP2( os, &fmtstr[star], f.wd, f.val ) \
                 } else {                                                                                /* precision */ \
                         fmtstr[sizeof(DFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
                         /* printf( "%g %d %d %s\n", f.val, f.wd, f.pc, &fmtstr[star] ); */ \
                         PrintWithDP2( os, &fmtstr[star], f.val, f.wd, f.pc ) \
+                        PrintWithDP2( os, &fmtstr[star], f.wd, f.pc, f.val ) \
                 } /* if */ \
                 return os; \
 …
 } // distribution
 FloatingPointFMTImpl( double, "%    * ", "%    *.* " )
 FloatingPointFMTImpl( long double, "%    *L ", "%    *.*L " )
+FloatingPointFMTImpl( double, "     * ", "     *.* " )
+FloatingPointFMTImpl( long double, "     *L ", "     *.*L " )
 // *********************************** character ***********************************
 forall( ostype & | ostream( ostype ) ) {
+forall( ostype & | basic_ostream( ostype ) ) {
         ostype & ?|?( ostype & os, _Ostream_Manip(char) f ) {
                 if ( f.base != 'c' ) {                                                  // bespoke binary/octal/hex format
 …
                 } // if
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 #define CFMTNP "% * "
 …
 // *********************************** C string ***********************************
 forall( ostype & | ostream( ostype ) ) {
+forall( ostype & | basic_ostream( ostype ) ) {
         ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f ) {
                 if ( ! f.val ) return os;                                               // null pointer ?
 …
                 } // if
                 if ( $sepPrt( os ) ) fmt( os, "%s", $sepGetCur( os ) );
+                if ( sepPrt$( os ) ) fmt( os, "%s", sepGetCur$( os ) );
                 #define SFMTNP "% * "
 …
 forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype & is, bool & b ) {
                 char val[6];
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, bool & b ) {
+                (istype &)(is | b); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, char & c ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, char & c ) {
+                (istype &)(is | c); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, signed char & sc ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, signed char & sc ) {
+                (istype &)(is | sc); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, unsigned char & usc ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, unsigned char & usc ) {
+                (istype &)(is | usc); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, short int & si ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, short int & si ) {
+                (istype &)(is | si); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, unsigned short int & usi ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, unsigned short int & usi ) {
+                (istype &)(is | usi); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, int & i ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, int & i ) {
+                (istype &)(is | i); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, unsigned int & ui ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, unsigned int & ui ) {
+                (istype &)(is | ui); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, long int & li ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, long int & li ) {
+                (istype &)(is | li); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, unsigned long int & ulli ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, unsigned long int & ulli ) {
+                (istype &)(is | ulli); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, long long int & lli ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, long long int & lli ) {
+                (istype &)(is | lli); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, unsigned long long int & ulli ) {
 …
                 return is;
         } // ?|?
+#if defined( __SIZEOF_INT128__ )
+        istype & ?|?( istype & is, int128 & i128 ) {
+                return (istype &)(is | (unsigned int128 &)i128);
+        } // ?|?
+        istype & ?|?( istype & is, unsigned int128 & ui128 ) {
+        void & ?|?( istype & is, unsigned long long int & ulli ) {
+                (istype &)(is | ulli); ends( is );
+        } // ?|?
+        #if defined( __SIZEOF_INT128__ )
+        istype & ?|?( istype & is, int128 & llli ) {
+                return (istype &)(is | (unsigned int128 &)llli);
+        } // ?|?
+        void ?|?( istype & is, int128 & llli ) {
+                (istype &)(is | llli); ends( is );
+        } // ?|?
+        istype & ?|?( istype & is, unsigned int128 & ullli ) {
                 char s[40];
                 bool sign = false;
 …
                 // If the input is too large, the value returned is undefined. If there is no input, no value is returned
                 if ( fmt( is, "%39[0-9]%*[0-9]", s ) == 1 ) {   // take first 39 characters, ignore remaining
                         ui128 = 0;
+                        ullli = 0;
                         for ( unsigned int i = 0; s[i] != '\0'; i += 1 ) {
                                 ui128 = ui128 * 10 + s[i] - '0';
+                                ullli = ullli * 10 + s[i] - '0';
                         } // for
                         if ( sign ) ui128 = -ui128;
+                        if ( sign ) ullli = -ullli;
                 } else if ( sign ) ungetc( is, '-' );                   // return minus when no digits
                 return is;
         } // ?|?
+#endif // __SIZEOF_INT128__
+        void ?|?( istype & is, unsigned int128 & ullli ) {
+                (istype &)(is | ullli); ends( is );
+        } // ?|?
+        #endif // __SIZEOF_INT128__
         istype & ?|?( istype & is, float & f ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, float & f ) {
+                (istype &)(is | f); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, double & d ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, double & d ) {
+                (istype &)(is | d); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, long double & ld ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, long double & ld ) {
+                (istype &)(is | ld); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, float _Complex & fc ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, float _Complex & fc ) {
+                (istype &)(is | fc); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, double _Complex & dc ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, double _Complex & dc ) {
+                (istype &)(is | dc); ends( is );
+        } // ?|?
         istype & ?|?( istype & is, long double _Complex & ldc ) {
 …
                 return is;
         } // ?|?
+        void ?|?( istype & is, long double _Complex & ldc ) {
+                (istype &)(is | ldc); ends( is );
+        } // ?|?
         // istype & ?|?( istype & is, const char fmt[] ) {
 …
         // } // ?|?
         istype & ?|?( istype & is, char * s ) {
+        istype & ?|?( istype & is, char s[] ) {
                 fmt( is, "%s", s );
                 return is;
+        } // ?|?
+        void ?|?( istype & is, char s[] ) {
+                (istype &)(is | s); ends( is );
         } // ?|?
 …
                 return manip( is );
         } // ?|?
+        void ?|?( istype & is, istype & (* manip)( istype & ) ) {
+                manip( is ); ends( is );
+        } // ?|?
         istype & nl( istype & is ) {
 …
 } // distribution
+forall( istype & | istream( istype ) ) {
+        istype & acquire( istype & is ) {
+                acquire( is );                                                                  // call void returning
+                return is;
+        } // acquire
+} // distribution
 // *********************************** manipulators ***********************************
+forall( istype & | istream( istype ) )
+istype & ?|?( istype & is, _Istream_Cstr f ) {
+        // skip xxx
+        if ( ! f.s ) {
+                // printf( "skip %s %d\n", f.scanset, f.wd );
+                if ( f.wd == -1 ) fmt( is, f.scanset, "" );             // no input arguments
+                else for ( f.wd ) fmt( is, "%*c" );
+                return is;
+        } // if
+        size_t len = 0;
+        if ( f.scanset ) len = strlen( f.scanset );
+        char fmtstr[len + 16];
+        int start = 1;
+        fmtstr[0] = '%';
+        if ( f.flags.ignore ) { fmtstr[1] = '*'; start += 1; }
+        if ( f.wd != -1 ) { start += sprintf( &fmtstr[start], "%d", f.wd ); }
+        // cstr %s, %*s, %ws, %*ws
+        if ( ! f.scanset ) {
+                fmtstr[start] = 's'; fmtstr[start + 1] = '\0';
+                // printf( "cstr %s\n", fmtstr );
+forall( istype & | basic_istream( istype ) ) {
+        istype & ?|?( istype & is, _Istream_Cstr f ) {
+                // skip xxx
+                if ( ! f.s ) {
+                        // printf( "skip %s %d\n", f.scanset, f.wd );
+                        if ( f.wd == -1 ) fmt( is, f.scanset, "" );             // no input arguments
+                        else for ( f.wd ) fmt( is, "%*c" );
+                        return is;
+                } // if
+                size_t len = 0;
+                if ( f.scanset ) len = strlen( f.scanset );
+                char fmtstr[len + 16];
+                int start = 1;
+                fmtstr[0] = '%';
+                if ( f.flags.ignore ) { fmtstr[1] = '*'; start += 1; }
+                if ( f.wd != -1 ) { start += sprintf( &fmtstr[start], "%d", f.wd ); }
+                // cstr %s, %*s, %ws, %*ws
+                if ( ! f.scanset ) {
+                        fmtstr[start] = 's'; fmtstr[start + 1] = '\0';
+                        // printf( "cstr %s\n", fmtstr );
+                        fmt( is, fmtstr, f.s );
+                        return is;
+                } // if
+                // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
+                // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
+                fmtstr[start] = '['; start += 1;
+                if ( f.flags.inex ) { fmtstr[start] = '^'; start += 1; }
+                strcpy( &fmtstr[start], f.scanset );                            // copy includes '\0'
+                len += start;
+                fmtstr[len] = ']'; fmtstr[len + 1] = '\0';
+                // printf( "incl/excl %s\n", fmtstr );
                 fmt( is, fmtstr, f.s );
                 return is;
+        } // if
+        // incl %[xxx],  %*[xxx],  %w[xxx],  %*w[xxx]
+        // excl %[^xxx], %*[^xxx], %w[^xxx], %*w[^xxx]
+        fmtstr[start] = '['; start += 1;
+        if ( f.flags.inex ) { fmtstr[start] = '^'; start += 1; }
+        strcpy( &fmtstr[start], f.scanset );                            // copy includes '\0'
+        len += start;
+        fmtstr[len] = ']'; fmtstr[len + 1] = '\0';
+        // printf( "incl/excl %s\n", fmtstr );
+        fmt( is, fmtstr, f.s );
+        return is;
+} // ?|?
+forall( istype & | istream( istype ) )
+istype & ?|?( istype & is, _Istream_Char f ) {
+        fmt( is, "%*c" );                                                                       // argument variable unused
+        return is;
+} // ?|?
+        } // ?|?
+        void ?|?( istype & is, _Istream_Cstr f ) {
+                (istype &)(is | f); ends( is );
+        } // ?|?
+        istype & ?|?( istype & is, _Istream_Char f ) {
+                fmt( is, "%*c" );                                                                       // argument variable unused
+                return is;
+        } // ?|?
+        void ?|?( istype & is, _Istream_Char f ) {
+                (istype &)(is | f); ends( is );
+        } // ?|?
+} // distribution
 #define InputFMTImpl( T, CODE ) \
+forall( istype & | istream( istype ) ) \
+istype & ?|?( istype & is, _Istream_Manip(T) f ) { \
+        enum { size = 16 }; \
+        char fmtstr[size]; \
+        if ( f.wd == -1 ) { \
+                snprintf( fmtstr, size, "%%%s%s", f.ignore ? "*" : "", CODE ); \
+        } else { \
+                snprintf( fmtstr, size, "%%%s%d%s", f.ignore ? "*" : "", f.wd, CODE ); \
+        } /* if */ \
+        /* printf( "%d %s %p\n", f.wd, fmtstr, &f.val ); */ \
+        fmt( is, fmtstr, &f.val ); \
+        return is; \
+} // ?|?
+forall( istype & | basic_istream( istype ) ) { \
+        istype & ?|?( istype & is, _Istream_Manip(T) f ) { \
+                enum { size = 16 }; \
+                char fmtstr[size]; \
+                if ( f.wd == -1 ) { \
+                        snprintf( fmtstr, size, "%%%s%s", f.ignore ? "*" : "", CODE ); \
+                } else { \
+                        snprintf( fmtstr, size, "%%%s%d%s", f.ignore ? "*" : "", f.wd, CODE ); \
+                } /* if */ \
+                /* printf( "%d %s %p\n", f.wd, fmtstr, &f.val ); */ \
+                fmt( is, fmtstr, &f.val ); \
+                return is; \
+        } /* ?|? */ \
+        void ?|?( istype & is, _Istream_Manip(T) f ) { \
+                (istype &)(is | f); ends( is ); \
+        } /* ?|? */ \
+} // distribution
 InputFMTImpl( signed char, "hhi" )
 …
 InputFMTImpl( long double, "Lf" )
+forall( istype & | istream( istype ) )
+istype & ?|?( istype & is, _Istream_Manip(float _Complex) fc ) {
+        float re, im;
+        _Istream_Manip(float) fmtuc @= { re, fc.wd, fc.ignore };
+        is | fmtuc;
+        &fmtuc.val = &im;
+        is | fmtuc;
+        if ( ! fc.ignore ) fc.val = re + im * _Complex_I;       // re/im are uninitialized for ignore
+        return is;
+} // ?|?
+forall( istype & | istream( istype ) )
+istype & ?|?( istype & is, _Istream_Manip(double _Complex) dc ) {
+        double re, im;
+        _Istream_Manip(double) fmtuc @= { re, dc.wd, dc.ignore };
+        is | fmtuc;
+        &fmtuc.val = &im;
+        is | fmtuc;
+        if ( ! dc.ignore ) dc.val = re + im * _Complex_I;       // re/im are uninitialized for ignore
+        return is;
+} // ?|?
+forall( istype & | istream( istype ) )
+istype & ?|?( istype & is, _Istream_Manip(long double _Complex) ldc ) {
+        long double re, im;
+        _Istream_Manip(long double) fmtuc @= { re, ldc.wd, ldc.ignore };
+        is | fmtuc;
+        &fmtuc.val = &im;
+        is | fmtuc;
+        if ( ! ldc.ignore ) ldc.val = re + im * _Complex_I;     // re/im are uninitialized for ignore
+        return is;
+} // ?|?
+forall( istype & | basic_istream( istype ) ) {
+        istype & ?|?( istype & is, _Istream_Manip(float _Complex) fc ) {
+                float re, im;
+                _Istream_Manip(float) fmtuc @= { re, fc.wd, fc.ignore };
+                is | fmtuc;
+                &fmtuc.val = &im;
+                is | fmtuc;
+                if ( ! fc.ignore ) fc.val = re + im * _Complex_I; // re/im are uninitialized for ignore
+                return is;
+        } // ?|?
+        void ?|?( istype & is, _Istream_Manip(float _Complex) fc ) {
+                (istype &)(is | fc); ends( is );
+        } // ?|?
+        istype & ?|?( istype & is, _Istream_Manip(double _Complex) dc ) {
+                double re, im;
+                _Istream_Manip(double) fmtuc @= { re, dc.wd, dc.ignore };
+                is | fmtuc;
+                &fmtuc.val = &im;
+                is | fmtuc;
+                if ( ! dc.ignore ) dc.val = re + im * _Complex_I; // re/im are uninitialized for ignore
+                return is;
+        } // ?|?
+        void ?|?( istype & is, _Istream_Manip(double _Complex) dc ) {
+                (istype &)(is | dc); ends( is );
+        } // ?|?
+        istype & ?|?( istype & is, _Istream_Manip(long double _Complex) ldc ) {
+                long double re, im;
+                _Istream_Manip(long double) fmtuc @= { re, ldc.wd, ldc.ignore };
+                is | fmtuc;
+                &fmtuc.val = &im;
+                is | fmtuc;
+                if ( ! ldc.ignore ) ldc.val = re + im * _Complex_I;     // re/im are uninitialized for ignore
+                return is;
+        } // ?|?
+        void ?|?( istype & is, _Istream_Manip(long double _Complex) ldc ) {
+                (istype &)(is | ldc); ends( is );
+        } // ?|?
+} // distribution
 // Local Variables: //

libcfa/src/iostream.hfa

-              rfeacef9
+              r5407cdc
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Aug 11 22:16:14 2020
 // Update Count     : 350
+// Last Modified On : Tue Apr 27 17:59:21 2021
+// Update Count     : 398
 //
 …
 trait ostream( ostype & ) {
+trait basic_ostream( ostype & ) {
         // private
         bool $sepPrt( ostype & );                                                       // get separator state (on/off)
         void $sepReset( ostype & );                                                     // set separator state to default state
         void $sepReset( ostype &, bool );                                       // set separator and default state
         const char * $sepGetCur( ostype & );                            // get current separator string
         void $sepSetCur( ostype &, const char [] );                     // set current separator string
         bool $getNL( ostype & );                                                        // check newline
         void $setNL( ostype &, bool );                                          // saw newline
         bool $getANL( ostype & );                                                       // get auto newline (on/off)
         bool $getPrt( ostype & );                                                       // get fmt called in output cascade
         void $setPrt( ostype &, bool );                                         // set fmt called in output cascade
+        bool sepPrt$( ostype & );                                                       // get separator state (on/off)
+        void sepReset$( ostype & );                                                     // set separator state to default state
+        void sepReset$( ostype &, bool );                                       // set separator and default state
+        const char * sepGetCur$( ostype & );                            // get current separator string
+        void sepSetCur$( ostype &, const char [] );                     // set current separator string
+        bool getNL$( ostype & );                                                        // check newline
+        void setNL$( ostype &, bool );                                          // saw newline
+        bool getANL$( ostype & );                                                       // get auto newline (on/off)
+        bool getPrt$( ostype & );                                                       // get fmt called in output cascade
+        void setPrt$( ostype &, bool );                                         // set fmt called in output cascade
         // public
         void sepOn( ostype & );                                                         // turn separator state on
 …
         void sepSetTuple( ostype &, const char [] );            // set tuple separator to string (15 character maximum)
+        void ends( ostype & os );                                                       // end of output statement
+        int fail( ostype & );
+        void ends( ostype & );                                                          // end of output statement
+        int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
+}; // basic_ostream
+trait ostream( ostype & | basic_ostream( ostype ) ) {
         int flush( ostype & );
+        void open( ostype & os, const char name[], const char mode[] );
+        void close( ostype & os );
+        bool fail( ostype & );                                                          // operation failed?
+        void open( ostype &, const char name[], const char mode[] );
+        void close( ostype & );
         ostype & write( ostype &, const char [], size_t );
         int fmt( ostype &, const char format[], ... ) __attribute__(( format(printf, 2, 3) ));
+        void acquire( ostype & );                                                       // concurrent access
 }; // ostream
 …
 // implement writable for intrinsic types
 forall( ostype & | ostream( ostype ) ) {
+forall( ostype & | basic_ostream( ostype ) ) {
         ostype & ?|?( ostype &, bool );
         void ?|?( ostype &, bool );
 …
         ostype & ?|?( ostype &, unsigned long long int );
         void ?|?( ostype &, unsigned long long int );
 #if defined( __SIZEOF_INT128__ )
+        #if defined( __SIZEOF_INT128__ )
         ostype & ?|?( ostype &, int128 );
         void ?|?( ostype &, int128 );
         ostype & ?|?( ostype &, unsigned int128 );
         void ?|?( ostype &, unsigned int128 );
 #endif // __SIZEOF_INT128__
+        #endif // __SIZEOF_INT128__
         ostype & ?|?( ostype &, float );
 …
         void ?|?( ostype &, const char [] );
         // ostype & ?|?( ostype &, const char16_t * );
 #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
+        #if ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 ) // char32_t == wchar_t => ambiguous
         // ostype & ?|?( ostype &, const char32_t * );
 #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
+        #endif // ! ( __ARM_ARCH_ISA_ARM == 1 && __ARM_32BIT_STATE == 1 )
         // ostype & ?|?( ostype &, const wchar_t * );
         ostype & ?|?( ostype &, const void * );
 …
 } // distribution
+forall( ostype & | ostream( ostype ) ) {
+        ostype & acquire( ostype & );
+} // distribution
 // tuples
 forall( ostype &, T, Params... | writeable( T, ostype ) | { ostype & ?|?( ostype &, Params ); } ) {
 …
 struct _Ostream_Manip {
         T val;                                                                                          // polymorphic base-type
         unsigned int wd, pc;                                                            // width, precision
+        int wd, pc;                                                                                     // width, precision: signed for computations
         char base;                                                                                      // numeric base / floating-point style
         union {
                 unsigned char all;
                 struct {
+                        unsigned char eng:1;                                            // engineering notation
                         unsigned char neg:1;                                            // val is negative
                         unsigned char pc:1;                                                     // precision specified
 …
         _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'x', { .all : 0 } }; } \
         _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, CODE, { .all : 0 } }; } \
         _Ostream_Manip(T) wd( unsigned int w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, CODE, { .flags.pc : true } }; } \
+        _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, CODE, { .flags.pc : true } }; } \
         _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
         _Ostream_Manip(T) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
         _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
         _Ostream_Manip(T) & upcase( _Ostream_Manip(T) & fmt ) { if ( fmt.base == 'x' || fmt.base == 'b' ) fmt.base -= 32; /* upper case */ return fmt; } \
 …
         _Ostream_Manip(T) & sign( _Ostream_Manip(T) & fmt ) { fmt.flags.sign = true; return fmt; } \
 } /* distribution */ \
 forall( ostype & | ostream( ostype ) ) { \
+forall( ostype & | basic_ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
         void ?|?( ostype & os, _Ostream_Manip(T) f ); \
 …
         _Ostream_Manip(T) hex( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'a', { .all : 0 } }; } \
         _Ostream_Manip(T) sci( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'e', { .all : 0 } }; } \
+        _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, 'f', { .all : 0 } }; } \
+        _Ostream_Manip(T) wd( unsigned int w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'f', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) ws( unsigned int w, unsigned char pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'g', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
+        _Ostream_Manip(T) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) eng( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.eng : true } }; } \
+        _Ostream_Manip(T) wd( unsigned int w, T val ) { return (_Ostream_Manip(T))@{ val, w, 0, 'g', { .all : 0 } }; } \
+        _Ostream_Manip(T) wd( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'f', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) ws( unsigned int w, unsigned int pc, T val ) { return (_Ostream_Manip(T))@{ val, w, pc, 'g', { .flags.pc : true } }; } \
+        _Ostream_Manip(T) & wd( unsigned int w, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; return fmt; } \
+        _Ostream_Manip(T) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { if ( fmt.flags.eng ) fmt.base = 'f'; fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
+        _Ostream_Manip(T) & ws( unsigned int w, unsigned int pc, _Ostream_Manip(T) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; } \
         _Ostream_Manip(T) & left( _Ostream_Manip(T) & fmt ) { fmt.flags.left = true; return fmt; } \
         _Ostream_Manip(T) upcase( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'G', { .all : 0 } }; } \
 …
         _Ostream_Manip(T) nodp( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.nobsdp : true } }; } \
         _Ostream_Manip(T) & nodp( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
+        _Ostream_Manip(T) unit( T val ) { return (_Ostream_Manip(T))@{ val, 1, 0, 'g', { .flags.nobsdp : true } }; } \
+        _Ostream_Manip(T) & unit( _Ostream_Manip(T) & fmt ) { fmt.flags.nobsdp = true; return fmt; } \
 } /* distribution */ \
 forall( ostype & | ostream( ostype ) ) { \
+forall( ostype & | basic_ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ); \
         void ?|?( ostype & os, _Ostream_Manip(T) f ); \
 …
         _Ostream_Manip(char) & nobase( _Ostream_Manip(char) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
 } // distribution
 forall( ostype & | ostream( ostype ) ) {
+forall( ostype & | basic_ostream( ostype ) ) {
         ostype & ?|?( ostype & os, _Ostream_Manip(char) f );
         void ?|?( ostype & os, _Ostream_Manip(char) f );
 …
         _Ostream_Manip(const char *) hex( const char s[] ) { return (_Ostream_Manip(const char *))@{ s, 1, 0, 'x', { .all : 0 } }; }
         _Ostream_Manip(const char *) wd( unsigned int w, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, 0, 's', { .all : 0 } }; }
         _Ostream_Manip(const char *) wd( unsigned int w, unsigned char pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
+        _Ostream_Manip(const char *) wd( unsigned int w, unsigned int pc, const char s[] ) { return (_Ostream_Manip(const char *))@{ s, w, pc, 's', { .flags.pc : true } }; }
         _Ostream_Manip(const char *) & wd( unsigned int w, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; return fmt; }
         _Ostream_Manip(const char *) & wd( unsigned int w, unsigned char pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
+        _Ostream_Manip(const char *) & wd( unsigned int w, unsigned int pc, _Ostream_Manip(const char *) & fmt ) { fmt.wd = w; fmt.pc = pc; fmt.flags.pc = true; return fmt; }
         _Ostream_Manip(const char *) & left( _Ostream_Manip(const char *) & fmt ) { fmt.flags.left = true; return fmt; }
         _Ostream_Manip(const char *) & nobase( _Ostream_Manip(const char *) & fmt ) { fmt.flags.nobsdp = true; return fmt; }
 } // distribution
 forall( ostype & | ostream( ostype ) ) {
+forall( ostype & | basic_ostream( ostype ) ) {
         ostype & ?|?( ostype & os, _Ostream_Manip(const char *) f );
         void ?|?( ostype & os, _Ostream_Manip(const char *) f );
 …
+trait istream( istype & ) {
+trait basic_istream( istype & ) {
+        bool getANL( istype & );                                                        // get scan newline (on/off)
         void nlOn( istype & );                                                          // read newline
         void nlOff( istype & );                                                         // scan newline
+        bool getANL( istype & );                                                        // get scan newline (on/off)
+        int fail( istype & );
+        void ends( istype & os );                                                       // end of output statement
+        int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+        istype & ungetc( istype &, char );
         int eof( istype & );
+}; // basic_istream
+trait istream( istype & | basic_istream( istype ) ) {
+        bool fail( istype & );
         void open( istype & is, const char name[] );
         void close( istype & is );
         istype & read( istype &, char *, size_t );
+        istype & ungetc( istype &, char );
+        int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
+        void acquire( istype & );                                                       // concurrent access
 }; // istream
 …
 }; // readable
 forall( istype & | istream( istype ) ) {
+forall( istype & | basic_istream( istype ) ) {
         istype & ?|?( istype &, bool & );
+        void ?|?( istype &, bool & );
         istype & ?|?( istype &, char & );
+        void ?|?( istype &, char & );
         istype & ?|?( istype &, signed char & );
+        void ?|?( istype &, signed char & );
         istype & ?|?( istype &, unsigned char & );
+        void ?|?( istype &, unsigned char & );
         istype & ?|?( istype &, short int & );
+        void ?|?( istype &, short int & );
         istype & ?|?( istype &, unsigned short int & );
+        void ?|?( istype &, unsigned short int & );
         istype & ?|?( istype &, int & );
+        void ?|?( istype &, int & );
         istype & ?|?( istype &, unsigned int & );
+        void ?|?( istype &, unsigned int & );
         istype & ?|?( istype &, long int & );
+        void ?|?( istype &, long int & );
         istype & ?|?( istype &, unsigned long int & );
+        void ?|?( istype &, unsigned long int & );
         istype & ?|?( istype &, long long int & );
+        void ?|?( istype &, long long int & );
         istype & ?|?( istype &, unsigned long long int & );
+#if defined( __SIZEOF_INT128__ )
+        void ?|?( istype &, unsigned long long int & );
+        #if defined( __SIZEOF_INT128__ )
         istype & ?|?( istype &, int128 & );
+        void ?|?( istype &, int128 & );
         istype & ?|?( istype &, unsigned int128 & );
+#endif // __SIZEOF_INT128__
+        void ?|?( istype &, unsigned int128 & );
+        #endif // __SIZEOF_INT128__
         istype & ?|?( istype &, float & );
+        void ?|?( istype &, float & );
         istype & ?|?( istype &, double & );
+        void ?|?( istype &, double & );
         istype & ?|?( istype &, long double & );
+        void ?|?( istype &, long double & );
         istype & ?|?( istype &, float _Complex & );
+        void ?|?( istype &, float _Complex & );
         istype & ?|?( istype &, double _Complex & );
+        void ?|?( istype &, double _Complex & );
         istype & ?|?( istype &, long double _Complex & );
+        void ?|?( istype &, long double _Complex & );
 //      istype & ?|?( istype &, const char [] );
+        istype & ?|?( istype &, char * );
+        istype & ?|?( istype &, char [] );
+        void ?|?( istype &, char [] );
         // manipulators
         istype & ?|?( istype &, istype & (*)( istype & ) );
+        void ?|?( istype &, istype & (*)( istype & ) );
         istype & nl( istype & is );
         istype & nlOn( istype & );
         istype & nlOff( istype & );
+} // distribution
+forall( istype & | istream( istype ) ) {
+        istype & acquire( istype & );
 } // distribution
 …
 static inline {
+        _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
         _Istream_Cstr skip( unsigned int n ) { return (_Istream_Cstr){ 0p, 0p, n, { .all : 0 } }; }
-        _Istream_Cstr skip( const char scanset[] ) { return (_Istream_Cstr){ 0p, scanset, -1, { .all : 0 } }; }
         _Istream_Cstr incl( const char scanset[], char * s ) { return (_Istream_Cstr){ s, scanset, -1, { .flags.inex : false } }; }
         _Istream_Cstr & incl( const char scanset[], _Istream_Cstr & fmt ) { fmt.scanset = scanset; fmt.flags.inex = false; return fmt; }
 …
         _Istream_Cstr & wdi( unsigned int w, _Istream_Cstr & fmt ) { fmt.wd = w; return fmt; }
 } // distribution
+forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Cstr f );
+forall( istype & | basic_istream( istype ) ) {
+        istype & ?|?( istype & is, _Istream_Cstr f );
+        void ?|?( istype & is, _Istream_Cstr f );
+}
 struct _Istream_Char {
 …
         _Istream_Char & ignore( _Istream_Char & fmt ) { fmt.ignore = true; return fmt; }
 } // distribution
+forall( istype & | istream( istype ) ) istype & ?|?( istype & is, _Istream_Char f );
+forall( istype & | basic_istream( istype ) ) {
+        istype & ?|?( istype & is, _Istream_Char f );
+        void ?|?( istype & is, _Istream_Char f );
+}
 forall( T & | sized( T ) )
 …
         _Istream_Manip(T) & wdi( unsigned int w, _Istream_Manip(T) & fmt ) { fmt.wd = w; return fmt; } \
 } /* distribution */ \
 forall( istype & | istream( istype ) ) { \
+forall( istype & | basic_istream( istype ) ) { \
         istype & ?|?( istype & is, _Istream_Manip(T) f ); \
+        void ?|?( istype & is, _Istream_Manip(T) f ); \
 } // ?|?

libcfa/src/math.hfa

-              rfeacef9
+              r5407cdc
 // file "LICENCE" distributed with Cforall.
 //
 // math --
+// math.hfa --
 //
 // Author           : Peter A. Buhr
 // Created On       : Mon Apr 18 23:37:04 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Aug 24 08:56:20 2020
 // Update Count     : 126
+// Last Modified On : Thu Apr 15 11:47:56 2021
+// Update Count     : 132
 //
 …
         long double _Complex log( long double _Complex x ) { return clogl( x ); }
+        // O(1) polymorphic integer log2, using clz, which returns the number of leading 0-bits, starting at the most
+        // significant bit (single instruction on x86)
+        int log2( unsigned int n ) { return n == 0 ? -1 : sizeof(n) * __CHAR_BIT__ - 1 - __builtin_clz( n ); }
+        long int log2( unsigned long int n ) { return n == 0 ? -1 : sizeof(n) * __CHAR_BIT__ - 1 - __builtin_clzl( n ); }
+        long long int log2( unsigned long long int n ) { return n == 0 ? -1 : sizeof(n) * __CHAR_BIT__ - 1 - __builtin_clzll( n ); }
         float log2( float x ) { return log2f( x ); }
         // extern "C" { double log2( double ); }

libcfa/src/startup.cfa

rfeacef9	r5407cdc
39	39
40	40	void disable_interrupts() __attribute__(( weak )) {}
41		void enable_interrupts~~_noPoll~~() __attribute__(( weak )) {}
	41	void enable_interrupts() __attribute__(( weak )) {}
42	42	} // extern "C"
43	43

libcfa/src/stdlib.hfa

-              rfeacef9
+              r5407cdc
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jan 21 22:02:13 2021
 // Update Count     : 574
+// Last Modified On : Tue Apr 20 21:20:03 2021
+// Update Count     : 575
 //
 …
 // Macro because of returns
 #define $ARRAY_ALLOC( allocation, alignment, dim ) \
+#define ARRAY_ALLOC$( allocation, alignment, dim ) \
         if ( _Alignof(T) <= libAlign() ) return (T *)(void *)allocation( dim, (size_t)sizeof(T) ); /* C allocation */ \
         else return (T *)alignment( _Alignof(T), dim, sizeof(T) )
 …
         T * aalloc( size_t dim ) {
                 $ARRAY_ALLOC( aalloc, amemalign, dim );
+                ARRAY_ALLOC$( aalloc, amemalign, dim );
         } // aalloc
         T * calloc( size_t dim ) {
                 $ARRAY_ALLOC( calloc, cmemalign, dim );
+                ARRAY_ALLOC$( calloc, cmemalign, dim );
         } // calloc
 …
                 S_fill(T) ?`fill( T    a[], size_t nmemb )      { S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
 . Replace the $alloc_internal function which is outside ttype forall-block with following function:
                 T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
+. Replace the alloc_internal$ function which is outside ttype forall-block with following function:
+                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill) {
                         T * ptr = NULL;
                         size_t size = sizeof(T);
 …
                         return ptr;
                 } // $alloc_internal
+                } // alloc_internal$
 */
 …
         S_realloc(T)    ?`realloc ( T * a )                             { return (S_realloc(T)){a}; }
         T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
+        T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
                 T * ptr = NULL;
                 size_t size = sizeof(T);
 …
                 return ptr;
         } // $alloc_internal
         forall( TT... | { T * $alloc_internal( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
                 T * $alloc_internal( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
                 return $alloc_internal( Resize, (T*)0p, Align, Dim, Fill, rest);
+                }
                 T * $alloc_internal( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
                 return $alloc_internal( (void*)0p, Realloc, Align, Dim, Fill, rest);
+                }
                 T * $alloc_internal( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
                 return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
+                }
                 T * $alloc_internal( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
                 return $alloc_internal( Resize, Realloc, Align, Dim, Fill, rest);
+        } // alloc_internal$
+        forall( TT... | { T * alloc_internal$( void *, T *, size_t, size_t, S_fill(T), TT ); } ) {
+                T * alloc_internal$( void *       , T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill, T_resize Resize, TT rest) {
+                return alloc_internal$( Resize, (T*)0p, Align, Dim, Fill, rest);
+                }
+                T * alloc_internal$( void * Resize, T *        , size_t Align, size_t Dim, S_fill(T) Fill, S_realloc(T) Realloc, TT rest) {
+                return alloc_internal$( (void*)0p, Realloc, Align, Dim, Fill, rest);
+                }
+                T * alloc_internal$( void * Resize, T * Realloc, size_t      , size_t Dim, S_fill(T) Fill, T_align Align, TT rest) {
+                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
+                }
+                T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T)     , S_fill(T) Fill, TT rest) {
+                return alloc_internal$( Resize, Realloc, Align, Dim, Fill, rest);
+                }
             T * alloc( TT all ) {
                 return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
+                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), (size_t)1, (S_fill(T)){'0'}, all);
+            }
             T * alloc( size_t dim, TT all ) {
                 return $alloc_internal( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
+                return alloc_internal$( (void*)0p, (T*)0p, (_Alignof(T) > libAlign() ? _Alignof(T) : libAlign()), dim, (S_fill(T)){'0'}, all);
+            }

libcfa/src/time.hfa

-              rfeacef9
+              r5407cdc
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jun 17 16:13:00 2020
 // Update Count     : 663
+// Last Modified On : Wed Apr 21 06:32:31 2021
+// Update Count     : 667
 //
 …
 static inline {
+        void ?{}( Duration & dur, timeval t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Duration & dur, timespec t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
+        Duration ?=?( Duration & dur, timeval t ) with( dur ) {
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
+                return dur;
+        } // ?=?
+        Duration ?=?( Duration & dur, timespec t ) with( dur ) {
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
+                return dur;
+        } // ?=?
         Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tn }; }
 …
         Duration ?%?( Duration lhs, Duration rhs ) { return (Duration)@{ lhs.tn % rhs.tn }; }
         Duration ?%=?( Duration & lhs, Duration rhs ) { lhs = lhs % rhs; return lhs; }
+        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
+        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
+        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
+        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
+        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
+        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
         bool ?==?( Duration lhs, Duration rhs ) { return lhs.tn == rhs.tn; }
 …
         bool ?>? ( Duration lhs, Duration rhs ) { return lhs.tn >  rhs.tn; }
         bool ?>=?( Duration lhs, Duration rhs ) { return lhs.tn >= rhs.tn; }
-        bool ?==?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn == 0; }
-        bool ?!=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn != 0; }
-        bool ?<? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <  0; }
-        bool ?<=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn <= 0; }
-        bool ?>? ( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >  0; }
-        bool ?>=?( Duration lhs, __attribute__((unused)) zero_t ) { return lhs.tn >= 0; }
         Duration abs( Duration rhs ) { return rhs.tn >= 0 ? rhs : -rhs; }
 …
 void ?{}( Time & time, int year, int month = 1, int day = 1, int hour = 0, int min = 0, int sec = 0, int64_t nsec = 0 );
 static inline {
+        void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Time ?=?( Time & time, __attribute__((unused)) zero_t ) { return time{ 0 }; }
-        void ?{}( Time & time, timeval t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
         Time ?=?( Time & time, timeval t ) with( time ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
                 return time;
         } // ?=?
-        void ?{}( Time & time, timespec t ) with( time ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
         Time ?=?( Time & time, timespec t ) with( time ) {
                 tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;

libcfa/src/virtual.c

-              rfeacef9
+              r5407cdc
 #include "virtual.h"
+#include "assert.h"
 int __cfa__is_parent( struct __cfa__parent_vtable const * parent,
         struct __cfa__parent_vtable const * child ) {
+        assert( child );
         do {
                 if ( parent == child )
 …
 void * __cfa__virtual_cast( struct __cfa__parent_vtable const * parent,
         struct __cfa__parent_vtable const * const * child ) {
+        assert( child );
         return (__cfa__is_parent(parent, *child)) ? (void *)child : (void *)0;
+}

src/AST/Convert.cpp

-              rfeacef9
+              r5407cdc
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Nov 12 10:07:00 2020
 // Update Count     : 34
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:43:51 2021
+// Update Count     : 36
 //
 …
         const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
                 auto decl = new AsmDecl( get<AsmStmt>().accept1( node->stmt ) );
+                declPostamble( decl, node );
+                return nullptr;
+        }
+        const ast::DirectiveDecl * visit( const ast::DirectiveDecl * node ) override final {
+                auto decl = new DirectiveDecl( get<DirectiveStmt>().accept1( node->stmt ) );
                 declPostamble( decl, node );
                 return nullptr;
 …
+        }
+        virtual void visit( const DirectiveDecl * old ) override final {
+                auto decl = new ast::DirectiveDecl{
+                        old->location,
+                        GET_ACCEPT_1(stmt, DirectiveStmt)
+                };
+                decl->extension  = old->extension;
+                decl->uniqueId   = old->uniqueId;
+                decl->storage    = { old->storageClasses.val };
+                this->node = decl;
+        }
         virtual void visit( const StaticAssertDecl * old ) override final {
                 auto decl = new ast::StaticAssertDecl{

src/AST/Decl.hpp

-              rfeacef9
+              r5407cdc
 // Created On       : Thu May 9 10:00:00 2019
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 11 20:48:38 2021
 // Update Count     : 30
+// Last Modified On : Fri Mar 12 18:25:05 2021
+// Update Count     : 32
 //
 …
 };
+/// C-preprocessor directive `#...`
+class DirectiveDecl : public Decl {
+public:
+        ptr<DirectiveStmt> stmt;
+        DirectiveDecl( const CodeLocation & loc, DirectiveStmt * stmt )
+        : Decl( loc, "", {}, {} ), stmt(stmt) {}
+        const DirectiveDecl * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        DirectiveDecl * clone() const override { return new DirectiveDecl( *this ); }
+        MUTATE_FRIEND
+};
 class StaticAssertDecl : public Decl {
 public:

src/AST/Expr.cpp

-              rfeacef9
+              r5407cdc
+}
+ConstantExpr * ConstantExpr::from_string( const CodeLocation & loc, const std::string & str ) {
+        const Type * charType = new BasicType( BasicType::Char );
+        // Adjust the length of the string for the terminator.
+        const Expr * strSize = from_ulong( loc, str.size() + 1 );
+        const Type * strType = new ArrayType( charType, strSize, FixedLen, StaticDim );
+        const std::string strValue = "\"" + str + "\"";
+        return new ConstantExpr( loc, strType, strValue, std::nullopt );
+}
 ConstantExpr * ConstantExpr::null( const CodeLocation & loc, const Type * ptrType ) {
         return new ConstantExpr{

src/AST/Expr.hpp

-              rfeacef9
+              r5407cdc
         long long int intValue() const;
         /// generates a boolean constant of the given bool
+        /// Generates a boolean constant of the given bool.
         static ConstantExpr * from_bool( const CodeLocation & loc, bool b );
         /// generates an integer constant of the given int
+        /// Generates an integer constant of the given int.
         static ConstantExpr * from_int( const CodeLocation & loc, int i );
         /// generates an integer constant of the given unsigned long int
+        /// Generates an integer constant of the given unsigned long int.
         static ConstantExpr * from_ulong( const CodeLocation & loc, unsigned long i );
+        /// generates a null pointer value for the given type. void * if omitted.
+        /// Generates a string constant from the given string (char type, unquoted string).
+        static ConstantExpr * from_string( const CodeLocation & loc, const std::string & string );
+        /// Generates a null pointer value for the given type. void * if omitted.
         static ConstantExpr * null( const CodeLocation & loc, const Type * ptrType = nullptr );

src/AST/Fwd.hpp

-              rfeacef9
+              r5407cdc
 // Author           : Andrew Beach
 // Created On       : Wed May  8 16:05:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr Jul 23 14:15:00 2020
 // Update Count     : 2
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:37:39 2021
+// Update Count     : 4
 //
 …
 class TypedefDecl;
 class AsmDecl;
+class DirectiveDecl;
 class StaticAssertDecl;

src/AST/Node.cpp

-              rfeacef9
+              r5407cdc
 // Author           : Thierry Delisle
 // Created On       : Thu May 16 14:16:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jun  5 10:21:00 2020
 // Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:25:06 2021
+// Update Count     : 2
 //
 …
 template class ast::ptr_base< ast::AsmDecl, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::AsmDecl, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::DirectiveDecl, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::DirectiveDecl, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::StaticAssertDecl, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::StaticAssertDecl, ast::Node::ref_type::strong >;

src/AST/Pass.hpp

rfeacef9	r5407cdc
139	139	const ast::Decl * visit( const ast::TypedefDecl * ) override final;
140	140	const ast::AsmDecl * visit( const ast::AsmDecl * ) override final;
	141	const ast::DirectiveDecl * visit( const ast::DirectiveDecl * ) override final;
141	142	const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl * ) override final;
142	143	const ast::CompoundStmt * visit( const ast::CompoundStmt * ) override final;

src/AST/Pass.impl.hpp

-              rfeacef9
+              r5407cdc
 //--------------------------------------------------------------------------
+// DirectiveDecl
+template< typename core_t >
+const ast::DirectiveDecl * ast::Pass< core_t >::visit( const ast::DirectiveDecl * node ) {
+        VISIT_START( node );
+        VISIT(
+                maybe_accept( node, &DirectiveDecl::stmt );
+        )
+        VISIT_END( DirectiveDecl, node );
+}
+//--------------------------------------------------------------------------
 // StaticAssertDecl
 template< typename core_t >

src/AST/Print.cpp

-              rfeacef9
+              r5407cdc
         virtual const ast::AsmDecl * visit( const ast::AsmDecl * node ) override final {
+                safe_print( node->stmt );
+                return node;
+        }
+        virtual const ast::DirectiveDecl * visit( const ast::DirectiveDecl * node ) override final {
                 safe_print( node->stmt );
                 return node;

src/AST/Type.cpp

-              rfeacef9
+              r5407cdc
+}
+// --- BaseInstType
 std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
 …
 template<typename decl_t>
 SueInstType<decl_t>::SueInstType(
         const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
 : BaseInstType( b->name, q, move(as) ), base( b ) {}
+        const base_type * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: BaseInstType( b->name, q, std::move(as) ), base( b ) {}
 template<typename decl_t>
 …
         const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
 : BaseInstType( b->name, q, move(as) ), base( b ) {}
+// --- TypeInstType
 void TypeInstType::set_base( const TypeDecl * b ) {

src/AST/Visitor.hpp

-              rfeacef9
+              r5407cdc
 // Author           : Andrew Beach
 // Created On       : Thr May 9 15:28:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Thr May 9 15:33:00 2019
 // Update Count     : 0
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:25:07 2021
+// Update Count     : 1
 //
 …
     virtual const ast::Decl *             visit( const ast::TypedefDecl          * ) = 0;
     virtual const ast::AsmDecl *          visit( const ast::AsmDecl              * ) = 0;
+    virtual const ast::DirectiveDecl *    visit( const ast::DirectiveDecl        * ) = 0;
     virtual const ast::StaticAssertDecl * visit( const ast::StaticAssertDecl     * ) = 0;
     virtual const ast::CompoundStmt *     visit( const ast::CompoundStmt         * ) = 0;

src/CodeGen/CodeGenerator.cc

-              rfeacef9
+              r5407cdc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 08:32:48 2020
 // Update Count     : 532
+// Last Modified On : Fri Mar 12 19:00:42 2021
+// Update Count     : 536
 //
 #include "CodeGenerator.h"
 …
                 if ( asmStmt->get_instruction() ) asmStmt->get_instruction()->accept( *visitor );
                 output << " )";
+        }
+        void CodeGenerator::postvisit( DirectiveDecl * directiveDecl ) {
+                output << endl << directiveDecl->get_stmt()->directive; // endl prevents spaces before directive
+        }

src/CodeGen/CodeGenerator.h

-              rfeacef9
+              r5407cdc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:58:31 2020
 // Update Count     : 62
+// Last Modified On : Fri Mar 12 18:35:38 2021
+// Update Count     : 63
 //
 …
                 void postvisit( DirectiveStmt * );
                 void postvisit( AsmDecl * );                                    // special: statement in declaration context
+                void postvisit( DirectiveDecl * );                              // special: statement in declaration context
                 void postvisit( IfStmt * );
                 void postvisit( SwitchStmt * );

src/Common/CodeLocationTools.cpp

-              rfeacef9
+              r5407cdc
 // Author           : Andrew Beach
 // Created On       : Fri Dec  4 15:42:00 2020
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed Dec  9  9:42:00 2020
 // Update Count     : 1
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Fri Mar 12 18:35:37 2021
+// Update Count     : 2
 //
 …
     macro(TypedefDecl, Decl) \
     macro(AsmDecl, AsmDecl) \
+    macro(DirectiveDecl, DirectiveDecl) \
     macro(StaticAssertDecl, StaticAssertDecl) \
     macro(CompoundStmt, CompoundStmt) \

src/Common/PassVisitor.h

-              rfeacef9
+              r5407cdc
         virtual void visit( AsmDecl * asmDecl ) override final;
         virtual void visit( const AsmDecl * asmDecl ) override final;
+        virtual void visit( DirectiveDecl * directiveDecl ) override final;
+        virtual void visit( const DirectiveDecl * directiveDecl ) override final;
         virtual void visit( StaticAssertDecl * assertDecl ) override final;
         virtual void visit( const StaticAssertDecl * assertDecl ) override final;
 …
         virtual Declaration * mutate( TypedefDecl * typeDecl ) override final;
         virtual AsmDecl * mutate( AsmDecl * asmDecl ) override final;
+        virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) override final;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) override final;

src/Common/PassVisitor.impl.h

-              rfeacef9
+              r5407cdc
 //--------------------------------------------------------------------------
+// DirectiveDecl
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( DirectiveDecl * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->stmt, *this );
+        VISIT_END( node );
+}
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const DirectiveDecl * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->stmt, *this );
+        VISIT_END( node );
+}
+template< typename pass_type >
+DirectiveDecl * PassVisitor< pass_type >::mutate( DirectiveDecl * node ) {
+        MUTATE_START( node );
+        maybeMutate_impl( node->stmt, *this );
+        MUTATE_END( DirectiveDecl, node );
+}
+//--------------------------------------------------------------------------
 // StaticAssertDecl
 template< typename pass_type >

src/Concurrency/Keywords.cc

-              rfeacef9
+              r5407cdc
 namespace Concurrency {
+        inline static std::string getTypeIdName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::typeIdType( exception_name );
+        }
         inline static std::string getVTableName( std::string const & exception_name ) {
                 return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName( exception_name );
+        }
 …
                   type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
                   context_error( context_error ), exception_name( exception_name ),
+                  typeid_name( getTypeIdName( exception_name ) ),
                   vtable_name( getVTableName( exception_name ) ),
                   needs_main( needs_main ), cast_target( cast_target ) {}
 …
                 void handle( StructDecl * );
+                void addTypeId( StructDecl * );
                 void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
 …
                 const std::string context_error;
                 const std::string exception_name;
+                const std::string typeid_name;
                 const std::string vtable_name;
                 bool needs_main;
 …
                 FunctionDecl * dtor_decl = nullptr;
                 StructDecl * except_decl = nullptr;
+                StructDecl * typeid_decl = nullptr;
                 StructDecl * vtable_decl = nullptr;
         };
 …
                         except_decl = decl;
+                }
+                else if ( !typeid_decl && typeid_name == decl->name && decl->body ) {
+                        typeid_decl = decl;
+                }
                 else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
                         vtable_decl = decl;
 …
                 if ( type_decl && isDestructorFor( decl, type_decl ) )
                         dtor_decl = decl;
+                else if ( vtable_name.empty() )
+                        ;
+                else if( !decl->has_body() )
+                else if ( vtable_name.empty() || !decl->has_body() )
+                        ;
                 else if ( auto param = isMainFor( decl, cast_target ) ) {
 …
                         std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
                         ObjectDecl * vtable_object = Virtual::makeVtableInstance(
+                                "_default_vtable_object_declaration",
                                 vtable_decl->makeInst( poly_args ), struct_type, nullptr );
                         declsToAddAfter.push_back( vtable_object );
+                        declsToAddAfter.push_back(
+                                new ObjectDecl(
+                                        Virtual::concurrentDefaultVTableName(),
+                                        Type::Const,
+                                        LinkageSpec::Cforall,
+                                        /* bitfieldWidth */ nullptr,
+                                        new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                        new SingleInit( new VariableExpr( vtable_object ) )
+                                )
+                        );
                         declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
                                 vtable_object, except_decl->makeInst( std::move( poly_args ) )
 …
                 if( !dtor_decl ) SemanticError( decl, context_error );
+                addVtableForward( decl );
+                if ( !exception_name.empty() ) {
+                        if( !typeid_decl ) SemanticError( decl, context_error );
+                        if( !vtable_decl ) SemanticError( decl, context_error );
+                        addTypeId( decl );
+                        addVtableForward( decl );
+                }
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
 …
+        }
+        void ConcurrentSueKeyword::addTypeId( StructDecl * decl ) {
+                assert( typeid_decl );
+                StructInstType typeid_type( Type::Const, typeid_decl );
+                typeid_type.parameters.push_back( new TypeExpr(
+                        new StructInstType( noQualifiers, decl )
+                        ) );
+                declsToAddBefore.push_back( Virtual::makeTypeIdInstance( &typeid_type ) );
+        }
         void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
+                if ( vtable_decl ) {
+                        std::list< Expression * > poly_args = {
+                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                        };
+                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                                vtable_decl->makeInst( poly_args ),
+                                except_decl->makeInst( poly_args )
+                        ) );
+                        declsToAddBefore.push_back( Virtual::makeVtableForward(
+                                vtable_decl->makeInst( move( poly_args ) ) ) );
+                // Its only an error if we want a vtable and don't have one.
+                } else if ( ! vtable_name.empty() ) {
+                        SemanticError( decl, context_error );
+                }
+                assert( vtable_decl );
+                std::list< Expression * > poly_args = {
+                        new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                };
+                declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                        vtable_decl->makeInst( poly_args ),
+                        except_decl->makeInst( poly_args )
+                ) );
+                ObjectDecl * vtable_object = Virtual::makeVtableForward(
+                        "_default_vtable_object_declaration",
+                        vtable_decl->makeInst( move( poly_args ) ) );
+                declsToAddBefore.push_back( vtable_object );
+                declsToAddBefore.push_back(
+                        new ObjectDecl(
+                                Virtual::concurrentDefaultVTableName(),
+                                Type::Const,
+                                LinkageSpec::Cforall,
+                                /* bitfieldWidth */ nullptr,
+                                new ReferenceType( Type::Const, vtable_object->type->clone() ),
+                                /* init */ nullptr
+                        )
+                );
+        }

src/Parser/DeclarationNode.cc

-              rfeacef9
+              r5407cdc
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 11 20:58:07 2021
 // Update Count     : 1137
+// Last Modified On : Tue Mar 23 08:44:08 2021
+// Update Count     : 1149
 //
 …
+}
-DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->name = name;
-        newnode->type = new TypeData( TypeData::Function );
-        newnode->type->function.params = param;
-        newnode->type->function.body = body;
-        if ( ret ) {
-                newnode->type->base = ret->type;
-                ret->type = nullptr;
-                delete ret;
-        } // if
-        return newnode;
-} // DeclarationNode::newFunction
 DeclarationNode * DeclarationNode::newStorageClass( Type::StorageClasses sc ) {
         DeclarationNode * newnode = new DeclarationNode;
 …
         return newnode;
 } // DeclarationNode::newForall
-DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::SymbolicInst );
-        newnode->type->symbolic.name = name;
-        newnode->type->symbolic.isTypedef = true;
-        newnode->type->symbolic.params = nullptr;
-        return newnode;
-} // DeclarationNode::newFromTypedef
 DeclarationNode * DeclarationNode::newFromGlobalScope() {
 …
 } // DeclarationNode::newEnum
+DeclarationNode * DeclarationNode::newName( const string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        assert( ! newnode->name );
+        newnode->name = name;
+        return newnode;
+} // DeclarationNode::newName
 DeclarationNode * DeclarationNode::newEnumConstant( const string * name, ExpressionNode * constant ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
+        DeclarationNode * newnode = newName( name );
         newnode->enumeratorValue.reset( constant );
         return newnode;
 } // DeclarationNode::newEnumConstant
+DeclarationNode * DeclarationNode::newName( const string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
+        return newnode;
+} // DeclarationNode::newName
+DeclarationNode * DeclarationNode::newFromTypedef( const string * name ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( TypeData::SymbolicInst );
+        newnode->type->symbolic.name = name;
+        newnode->type->symbolic.isTypedef = true;
+        newnode->type->symbolic.params = nullptr;
+        return newnode;
+} // DeclarationNode::newFromTypedef
 DeclarationNode * DeclarationNode::newFromTypeGen( const string * name, ExpressionNode * params ) {
 …
 DeclarationNode * DeclarationNode::newTypeParam( TypeDecl::Kind tc, const string * name ) {
         DeclarationNode * newnode = new DeclarationNode;
+        DeclarationNode * newnode = newName( name );
         newnode->type = nullptr;
-        assert( ! newnode->name );
-//      newnode->variable.name = name;
-        newnode->name = name;
         newnode->variable.tyClass = tc;
         newnode->variable.assertions = nullptr;
 …
 DeclarationNode * DeclarationNode::newTypeDecl( const string * name, DeclarationNode * typeParams ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->name = name;
+        DeclarationNode * newnode = newName( name );
         newnode->type = new TypeData( TypeData::Symbolic );
         newnode->type->symbolic.isTypedef = false;
 …
 } // DeclarationNode::newBuiltinType
+DeclarationNode * DeclarationNode::newFunction( const string * name, DeclarationNode * ret, DeclarationNode * param, StatementNode * body ) {
+        DeclarationNode * newnode = newName( name );
+        newnode->type = new TypeData( TypeData::Function );
+        newnode->type->function.params = param;
+        newnode->type->function.body = body;
+        if ( ret ) {
+                newnode->type->base = ret->type;
+                ret->type = nullptr;
+                delete ret;
+        } // if
+        return newnode;
+} // DeclarationNode::newFunction
 DeclarationNode * DeclarationNode::newAttribute( const string * name, ExpressionNode * expr ) {
         DeclarationNode * newnode = new DeclarationNode;
 …
         newnode->attributes.push_back( new Attribute( *name, exprs ) );
         delete name;
+        return newnode;
+}
+DeclarationNode * DeclarationNode::newDirectiveStmt( StatementNode * stmt ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->directiveStmt = stmt;
         return newnode;
+}
 …
+}
 DeclarationNode * DeclarationNode::cloneType( string * newName ) {
         DeclarationNode * newnode = new DeclarationNode;
+DeclarationNode * DeclarationNode::cloneType( string * name ) {
+        DeclarationNode * newnode = newName( name );
         newnode->type = maybeClone( type );
         newnode->copySpecifiers( this );
-        assert( newName );
-        newnode->name = newName;
         return newnode;
+}
 …
                 return new AsmDecl( strict_dynamic_cast<AsmStmt *>( asmStmt->build() ) );
         } // if
+        if ( directiveStmt ) {
+                return new DirectiveDecl( strict_dynamic_cast<DirectiveStmt *>( directiveStmt->build() ) );
+        } // if
         if ( variable.tyClass != TypeDecl::NUMBER_OF_KINDS ) {

src/Parser/ParseNode.h

-              rfeacef9
+              r5407cdc
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Jan  3 18:23:01 2021
 // Update Count     : 896
+// Last Modified On : Fri Mar 12 15:19:04 2021
+// Update Count     : 897
 //
 …
         static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
         static DeclarationNode * newAttribute( const std::string *, ExpressionNode * expr = nullptr ); // gcc attributes
+        static DeclarationNode * newDirectiveStmt( StatementNode * stmt ); // gcc external directive statement
         static DeclarationNode * newAsmStmt( StatementNode * stmt ); // gcc external asm statement
         static DeclarationNode * newStaticAssert( ExpressionNode * condition, Expression * message );
 …
         std::string error;
         StatementNode * asmStmt = nullptr;
+        StatementNode * directiveStmt = nullptr;
         static UniqueName anonymous;

src/Parser/TypeData.h

-              rfeacef9
+              r5407cdc
 // TypeData.h --
 //
 // Author           : Rodolfo G. Esteves
+// Author           : Peter A. Buhr
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:42:35 2019
 // Update Count     : 199
+// Last Modified On : Sat Mar 27 09:05:35 2021
+// Update Count     : 200
 //
 #pragma once
 #include <iosfwd>                // for ostream
 #include <list>                  // for list
 #include <string>                // for string
+#include <iosfwd>                                                                               // for ostream
+#include <list>                                                                                 // for list
+#include <string>                                                                               // for string
 #include "ParseNode.h"           // for DeclarationNode, DeclarationNode::Ag...
 #include "SynTree/LinkageSpec.h" // for Spec
 #include "SynTree/Type.h"        // for Type, ReferenceToType (ptr only)
 #include "SynTree/SynTree.h"     // for Visitor Nodes
+#include "ParseNode.h"                                                                  // for DeclarationNode, DeclarationNode::Ag...
+#include "SynTree/LinkageSpec.h"                                                // for Spec
+#include "SynTree/Type.h"                                                               // for Type, ReferenceToType (ptr only)
+#include "SynTree/SynTree.h"                                                    // for Visitor Nodes
 struct TypeData {
 …
                 const std::string * name = nullptr;
                 DeclarationNode * params = nullptr;
                 ExpressionNode * actuals = nullptr;                                             // holds actual parameters later applied to AggInst
+                ExpressionNode * actuals = nullptr;                             // holds actual parameters later applied to AggInst
                 DeclarationNode * fields = nullptr;
                 bool body;
 …
         struct Function_t {
                 mutable DeclarationNode * params = nullptr;                             // mutables modified in buildKRFunction
                 mutable DeclarationNode * idList = nullptr;                             // old-style
+                mutable DeclarationNode * params = nullptr;             // mutables modified in buildKRFunction
+                mutable DeclarationNode * idList = nullptr;             // old-style
                 mutable DeclarationNode * oldDeclList = nullptr;
                 StatementNode * body = nullptr;
                 ExpressionNode * withExprs = nullptr;                                           // expressions from function's with_clause
+                ExpressionNode * withExprs = nullptr;                   // expressions from function's with_clause
         };

src/Parser/TypedefTable.cc

-              rfeacef9
+              r5407cdc
 // Created On       : Sat May 16 15:20:13 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 08:06:36 2020
 // Update Count     : 259
+// Last Modified On : Mon Mar 15 20:56:47 2021
+// Update Count     : 260
 //
 …
         debugPrint( cerr << "Adding enclosing at " << locn << " " << identifier << " as " << kindName( kind ) << " scope " << scope << " level " << level << " note " << kindTable.getNote( kindTable.currentScope() - 1 ).level << endl );
         auto ret = kindTable.insertAt( scope, identifier, kind );
         if ( ! ret.second ) ret.first->second = kind;   // exists => update
+        if ( ! ret.second ) ret.first->second = kind;           // exists => update
 } // TypedefTable::addToEnclosingScope

src/Parser/lex.ll

-              rfeacef9
+              r5407cdc
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Tue Oct  6 18:15:41 2020
  * Update Count     : 743
+ * Last Modified On : Thu Apr  1 13:22:31 2021
+ * Update Count     : 754
  */
 …
 break                   { KEYWORD_RETURN(BREAK); }
 case                    { KEYWORD_RETURN(CASE); }
 catch                   { KEYWORD_RETURN(CATCH); }                              // CFA
 catchResume             { KEYWORD_RETURN(CATCHRESUME); }                // CFA
+catch                   { QKEYWORD_RETURN(CATCH); }                             // CFA
+catchResume             { QKEYWORD_RETURN(CATCHRESUME); }               // CFA
 char                    { KEYWORD_RETURN(CHAR); }
 choose                  { KEYWORD_RETURN(CHOOSE); }                             // CFA
 …
 fallthrough             { KEYWORD_RETURN(FALLTHROUGH); }                // CFA
 fallthru                { KEYWORD_RETURN(FALLTHRU); }                   // CFA
+finally                 { KEYWORD_RETURN(FINALLY); }                    // CFA
+finally                 { QKEYWORD_RETURN(FINALLY); }                   // CFA
+fixup                   { QKEYWORD_RETURN(FIXUP); }                             // CFA
 float                   { KEYWORD_RETURN(FLOAT); }
 __float80               { KEYWORD_RETURN(uuFLOAT80); }                  // GCC
 …
 or                              { QKEYWORD_RETURN(WOR); }                               // CFA
 otype                   { KEYWORD_RETURN(OTYPE); }                              // CFA
+recover                 { QKEYWORD_RETURN(RECOVER); }                   // CFA
 register                { KEYWORD_RETURN(REGISTER); }
+report                  { KEYWORD_RETURN(THROWRESUME); }                // CFA
 restrict                { KEYWORD_RETURN(RESTRICT); }                   // C99
 __restrict              { KEYWORD_RETURN(RESTRICT); }                   // GCC
 …
 __typeof                { KEYWORD_RETURN(TYPEOF); }                             // GCC
 __typeof__              { KEYWORD_RETURN(TYPEOF); }                             // GCC
+typeid                  { KEYWORD_RETURN(TYPEID); }                             // GCC
 union                   { KEYWORD_RETURN(UNION); }
 __uint128_t             { KEYWORD_RETURN(UINT128); }                    // GCC
 …
 __volatile              { KEYWORD_RETURN(VOLATILE); }                   // GCC
 __volatile__    { KEYWORD_RETURN(VOLATILE); }                   // GCC
+waitfor                 { KEYWORD_RETURN(WAITFOR); }
+when                    { KEYWORD_RETURN(WHEN); }
+vtable                  { KEYWORD_RETURN(VTABLE); }                             // CFA
+waitfor                 { KEYWORD_RETURN(WAITFOR); }                    // CFA
+when                    { KEYWORD_RETURN(WHEN); }                               // CFA
 while                   { KEYWORD_RETURN(WHILE); }
 with                    { KEYWORD_RETURN(WITH); }                               // CFA

src/Parser/parser.yy

-              rfeacef9
+              r5407cdc
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Feb  3 18:30:12 2021
 // Update Count     : 4700
+// Last Modified On : Mon Apr 26 18:41:54 2021
+// Update Count     : 4990
 //
 …
 //
 // 1. designation with and without '=' (use ':' instead)
+// 2. attributes not allowed in parenthesis of declarator
 //
 // All of the syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall
 …
 } // forCtrl
 bool forall = false, yyy = false;                                               // aggregate have one or more forall qualifiers ?
+bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
 // https://www.gnu.org/software/bison/manual/bison.html#Location-Type
 …
 %token RESTRICT                                                                                 // C99
 %token ATOMIC                                                                                   // C11
 %token FORALL MUTEX VIRTUAL COERCE                                              // CFA
+%token FORALL MUTEX VIRTUAL VTABLE COERCE                               // CFA
 %token VOID CHAR SHORT INT LONG FLOAT DOUBLE SIGNED UNSIGNED
 %token BOOL COMPLEX IMAGINARY                                                   // C99
 …
 %token uFLOAT16 uFLOAT32 uFLOAT32X uFLOAT64 uFLOAT64X uFLOAT128 // GCC
 %token ZERO_T ONE_T                                                                             // CFA
+%token VALIST                                                                                   // GCC
+%token AUTO_TYPE                                                                                // GCC
+%token TYPEOF BASETYPEOF LABEL                                                  // GCC
+%token SIZEOF TYPEOF VALIST AUTO_TYPE                                   // GCC
+%token OFFSETOF BASETYPEOF TYPEID                                               // CFA
 %token ENUM STRUCT UNION
 %token EXCEPTION                                                                                // CFA
 %token GENERATOR COROUTINE MONITOR THREAD                               // CFA
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
-%token SIZEOF OFFSETOF
 // %token RESUME                                                                                        // CFA
+%token LABEL                                                                                    // GCC
 %token SUSPEND                                                                                  // CFA
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
+%token CHOOSE DISABLE ENABLE FALLTHRU FALLTHROUGH TRY CATCH CATCHRESUME FINALLY THROW THROWRESUME AT WITH WHEN WAITFOR // CFA
+%token CHOOSE FALLTHRU FALLTHROUGH WITH WHEN WAITFOR    // CFA
+%token DISABLE ENABLE TRY THROW THROWRESUME AT                  // CFA
 %token ASM                                                                                              // C99, extension ISO/IEC 9899:1999 Section J.5.10(1)
 %token ALIGNAS ALIGNOF GENERIC STATICASSERT                             // C11
 // names and constants: lexer differentiates between identifier and typedef names
 %token<tok> IDENTIFIER                  QUOTED_IDENTIFIER               TYPEDEFname                             TYPEGENname
 %token<tok> TIMEOUT                             WOR
 %token<tok> INTEGERconstant             CHARACTERconstant               STRINGliteral
+%token<tok> IDENTIFIER          QUOTED_IDENTIFIER       TYPEDEFname             TYPEGENname
+%token<tok> TIMEOUT                     WOR                                     CATCH                   RECOVER                 CATCHRESUME             FIXUP           FINALLY         // CFA
+%token<tok> INTEGERconstant     CHARACTERconstant       STRINGliteral
 %token<tok> DIRECTIVE
 // Floating point constant is broken into three kinds of tokens because of the ambiguity with tuple indexing and
 …
 %type<en> constant
 %type<en> tuple                                                 tuple_expression_list
 %type<op> ptrref_operator                               unary_operator                          assignment_operator
+%type<op> ptrref_operator                               unary_operator                          assignment_operator                     simple_assignment_operator      compound_assignment_operator
 %type<en> primary_expression                    postfix_expression                      unary_expression
 %type<en> cast_expression_list                  cast_expression                         exponential_expression          multiplicative_expression       additive_expression
 …
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
+%type<decl> vtable vtable_opt default_opt
 %type<decl> trait_declaration trait_declaration_list trait_declaring_list trait_specifier
 …
 %type<decl> type_declaration_specifier type_type_specifier type_name typegen_name
 %type<decl> typedef typedef_declaration typedef_expression
+%type<decl> typedef_name typedef_declaration typedef_expression
 %type<decl> variable_type_redeclarator type_ptr type_array type_function
 …
 %type<decl> type_qualifier type_qualifier_name forall type_qualifier_list_opt type_qualifier_list
 %type<decl> type_specifier type_specifier_nobody enum_specifier_nobody
+%type<decl> type_specifier type_specifier_nobody
 %type<decl> variable_declarator variable_ptr variable_array variable_function
 %type<decl> variable_abstract_declarator variable_abstract_ptr variable_abstract_array variable_abstract_function
 %type<decl> attribute_list_opt attribute_list attribute_opt attribute attribute_name_list attribute_name
+%type<decl> attribute_list_opt attribute_list attribute attribute_name_list attribute_name
 // initializers
 …
 // Order of these lines matters (low-to-high precedence). THEN is left associative over WOR/TIMEOUT/ELSE, WOR is left
 // associative over TIMEOUT/ELSE, and TIMEOUT is left associative over ELSE.
+%precedence THEN        // rule precedence for IF/WAITFOR statement
+%precedence WOR         // token precedence for start of WOR in WAITFOR statement
+%precedence TIMEOUT     // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
+%precedence THEN                // rule precedence for IF/WAITFOR statement
+%precedence WOR                 // token precedence for start of WOR in WAITFOR statement
+%precedence TIMEOUT             // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence CATCH               // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence RECOVER             // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence CATCHRESUME // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence FIXUP               // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence FINALLY             // token precedence for start of TIMEOUT in WAITFOR statement
+%precedence ELSE                // token precedence for start of else clause in IF/WAITFOR statement
 // Handle shift/reduce conflict for generic type by shifting the '(' token. For example, this string is ambiguous:
 …
         TIMEOUT
         | WOR
+        | CATCH
+        | RECOVER
+        | CATCHRESUME
+        | FIXUP
+        | FINALLY
+        ;
 …
         | OFFSETOF '(' type_no_function ',' identifier ')'
                 { $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) ); }
+        | TYPEID '(' type_no_function ')'
+                {
+                        SemanticError( yylloc, "typeid name is currently unimplemented." ); $$ = nullptr;
+                        // $$ = new ExpressionNode( build_offsetOf( $3, build_varref( $5 ) ) );
+                }
+        ;
 …
                 { $$ = new ExpressionNode( build_cast( $2, $4 ) ); }
         | '(' aggregate_control '&' ')' cast_expression         // CFA
+                { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
+        | '(' aggregate_control '*' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
         | '(' VIRTUAL ')' cast_expression                                       // CFA
 …
 assignment_operator:
+        simple_assignment_operator
+        | compound_assignment_operator
+        ;
+simple_assignment_operator:
         '='                                                                                     { $$ = OperKinds::Assign; }
+        | ATassign                                                                      { $$ = OperKinds::AtAssn; }
+        | EXPassign                                                                     { $$ = OperKinds::ExpAssn; }
+        | ATassign                                                                      { $$ = OperKinds::AtAssn; } // CFA
+        ;
+compound_assignment_operator:
+        EXPassign                                                                       { $$ = OperKinds::ExpAssn; }
         | MULTassign                                                            { $$ = OperKinds::MulAssn; }
         | DIVassign                                                                     { $$ = OperKinds::DivAssn; }
 …
                 { $$ = new StatementNode( build_compound( (StatementNode *)0 ) ); }
         | '{' push
           local_label_declaration_opt                                           // GCC, local labels
+          local_label_declaration_opt                                           // GCC, local labels appear at start of block
           statement_decl_list                                                           // C99, intermix declarations and statements
           pop '}'
 …
         | comma_expression ';' comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
+        | comma_expression ';' TYPEDEFname                                      // CFA, array type
+                {
+                        SemanticError( yylloc, "Array interator is currently unimplemented." ); $$ = nullptr;
+                        $$ = forCtrl( new ExpressionNode( build_varref( $3 ) ), $1, nullptr, OperKinds::Range, nullptr, nullptr );
+                }
                 // There is a S/R conflicit if ~ and -~ are factored out.
 …
 exception_statement:
         TRY compound_statement handler_clause
+        TRY compound_statement handler_clause                                   %prec THEN
                 { $$ = new StatementNode( build_try( $2, $3, 0 ) ); }
         | TRY compound_statement finally_clause
 …
 handler_key:
         CATCH                                                                           { $$ = CatchStmt::Terminate; }
+        | RECOVER                                                                       { $$ = CatchStmt::Terminate; }
         | CATCHRESUME                                                           { $$ = CatchStmt::Resume; }
+        | FIXUP                                                                         { $$ = CatchStmt::Resume; }
+        ;
 …
+        ;
-enum_specifier_nobody:                                                                  // type specifier - {...}
-                // Preclude SUE declarations in restricted scopes (see type_specifier_nobody)
-        basic_type_specifier
-        | sue_type_specifier_nobody
+        ;
 type_qualifier_list_opt:                                                                // GCC, used in asm_statement
         // empty
 …
 type_qualifier:
         type_qualifier_name
         | attribute
+        | attribute                                                                                     // trick handles most atrribute locations
+        ;
 …
         | AUTO_TYPE
                 { $$ = DeclarationNode::newBuiltinType( DeclarationNode::AutoType ); }
+        | vtable
+        ;
+vtable_opt:
+        // empty
+                { $$ = nullptr; }
+        | vtable;
+        ;
+vtable:
+        VTABLE '(' type_list ')' default_opt
+                { SemanticError( yylloc, "vtable is currently unimplemented." ); $$ = nullptr; }
+        ;
+default_opt:
+        // empty
+                { $$ = nullptr; }
+        | DEFAULT
+                { SemanticError( yylloc, "vtable default is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
           '{' field_declaration_list_opt '}' type_parameters_opt
                 { $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 ); }
+        | aggregate_key attribute_list_opt type_name
+                {
+                        // for type_name can be a qualified type name S.T, in which case only the last name in the chain needs a typedef (other names in the chain should already have one)
+                        typedefTable.makeTypedef( *$3->type->leafName(), forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
+        | aggregate_key attribute_list_opt TYPEDEFname          // unqualified type name
+                {
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
                         forall = false;                                                         // reset
+                }
           '{' field_declaration_list_opt '}' type_parameters_opt
+                { $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $8, $6, true )->addQualifiers( $2 ); }
+                {
+                        DeclarationNode::newFromTypedef( $3 );
+                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
+                }
+        | aggregate_key attribute_list_opt TYPEGENname          // unqualified type name
+                {
+                        typedefTable.makeTypedef( *$3, forall || typedefTable.getEnclForall() ? TYPEGENname : TYPEDEFname ); // create typedef
+                        forall = false;                                                         // reset
+                }
+          '{' field_declaration_list_opt '}' type_parameters_opt
+                {
+                        DeclarationNode::newFromTypeGen( $3, nullptr );
+                        $$ = DeclarationNode::newAggregate( $1, $3, $8, $6, true )->addQualifiers( $2 );
+                }
         | aggregate_type_nobody
+        ;
 …
 aggregate_data:
         STRUCT
                 { yyy = true; $$ = AggregateDecl::Struct; }
+        STRUCT vtable_opt
+                { $$ = AggregateDecl::Struct; }
         | UNION
                 { yyy = true; $$ = AggregateDecl::Union; }
+                { $$ = AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
                 // { yyy = true; $$ = AggregateDecl::Exception; }
                 { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+                { $$ = AggregateDecl::Exception; }
+          //            { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+        ;
 aggregate_control:                                                                              // CFA
         MONITOR
                 { yyy = true; $$ = AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | MUTEX STRUCT
                 { yyy = true; $$ = AggregateDecl::Monitor; }
+                { $$ = AggregateDecl::Monitor; }
         | GENERATOR
                 { yyy = true; $$ = AggregateDecl::Generator; }
+                { $$ = AggregateDecl::Generator; }
         | MUTEX GENERATOR
                 { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
                 { yyy = true; $$ = AggregateDecl::Coroutine; }
+                { $$ = AggregateDecl::Coroutine; }
         | MUTEX COROUTINE
                 { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
                 { yyy = true; $$ = AggregateDecl::Thread; }
+                { $$ = AggregateDecl::Thread; }
         | MUTEX THREAD
                 { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
 …
+        ;
-// Cannot use attribute_list_opt because of ambiguity with enum_specifier_nobody, which already parses attribute.
-// Hence, only a single attribute is allowed after the "ENUM".
 enum_type:                                                                                              // enum
         ENUM attribute_opt '{' enumerator_list comma_opt '}'
+        ENUM attribute_list_opt '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( nullptr, $4, true )->addQualifiers( $2 ); }
         | ENUM attribute_opt identifier
+        | ENUM attribute_list_opt identifier
                 { typedefTable.makeTypedef( *$3 ); }
           '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( $3, $6, true )->addQualifiers( $2 ); }
         | ENUM attribute_opt typedef                                            // enum cannot be generic
+        | ENUM attribute_list_opt typedef_name                          // unqualified type name
           '{' enumerator_list comma_opt '}'
                 { $$ = DeclarationNode::newEnum( $3->name, $5, true )->addQualifiers( $2 ); }
+        | ENUM enum_specifier_nobody '{' enumerator_list comma_opt '}'
+                // { $$ = DeclarationNode::newEnum( nullptr, $4, true ); }
+                { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
+        | ENUM enum_specifier_nobody declarator '{' enumerator_list comma_opt '}'
+                // {
+                //      typedefTable.makeTypedef( *$3->name );
+                //      $$ = DeclarationNode::newEnum( nullptr, $5, true );
+                // }
+                { SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr; }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt identifier attribute_list_opt
+                {
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        typedefTable.makeTypedef( *$6 );
+                }
+          '{' enumerator_list comma_opt '}'
+                {
+                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                }
+        | ENUM '(' cfa_abstract_parameter_declaration ')' attribute_list_opt typedef_name attribute_list_opt '{' enumerator_list comma_opt '}'
+                {
+                        if ( $3->storageClasses.val != 0 || $3->type->qualifiers.val != 0 ) { SemanticError( yylloc, "storage-class and CV qualifiers are not meaningful for enumeration constants, which are const." ); }
+                        typedefTable.makeTypedef( *$6->name );
+                        SemanticError( yylloc, "Typed enumeration is currently unimplemented." ); $$ = nullptr;
+                }
         | enum_type_nobody
+        ;
 enum_type_nobody:                                                                               // enum - {...}
+        ENUM attribute_opt identifier
+                {
+                        typedefTable.makeTypedef( *$3 );
+                        $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 );
+                }
+        | ENUM attribute_opt type_name                                          // enum cannot be generic
+                {
+                        typedefTable.makeTypedef( *$3->type->symbolic.name );
+                        $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 );
+                }
+        ENUM attribute_list_opt identifier
+                { typedefTable.makeTypedef( *$3 ); $$ = DeclarationNode::newEnum( $3, 0, false )->addQualifiers( $2 ); }
+        | ENUM attribute_list_opt type_name                                     // qualified type name
+                { typedefTable.makeTypedef( *$3->type->symbolic.name ); $$ = DeclarationNode::newEnum( $3->type->symbolic.name, 0, false )->addQualifiers( $2 ); }
+        ;
 …
         identifier_or_type_name enumerator_value_opt
                 { $$ = DeclarationNode::newEnumConstant( $1, $2 ); }
+        | INLINE type_name
+                { $$ = DeclarationNode::newEnumConstant( new string("inline"), nullptr ); }
         | enumerator_list ',' identifier_or_type_name enumerator_value_opt
                 { $$ = $1->appendList( DeclarationNode::newEnumConstant( $3, $4 ) ); }
+        | enumerator_list ',' INLINE type_name enumerator_value_opt
+                { $$ = $1->appendList( DeclarationNode::newEnumConstant( new string("inline"), nullptr ) ); }
+        ;
 …
         // | '=' constant_expression
         //      { $$ = $2; }
         | '=' initializer
+        | simple_assignment_operator initializer
                 { $$ = $2->get_expression(); }                                  // FIX ME: enum only deals with constant_expression
+        ;
 …
         // empty
                 { $$ = nullptr; }
+        | '=' initializer
+                { $$ = $2; }
+        | '=' VOID
+                { $$ = new InitializerNode( true ); }
+        | ATassign initializer
+                { $$ = $2->set_maybeConstructed( false ); }
+        | simple_assignment_operator initializer        { $$ = $1 == OperKinds::Assign ? $2 : $2->set_maybeConstructed( false ); }
+        | '=' VOID                                                                      { $$ = new InitializerNode( true ); }
+        ;
 …
 external_definition:
+        declaration
+        DIRECTIVE
+                { $$ = DeclarationNode::newDirectiveStmt( new StatementNode( build_directive( $1 ) ) ); }
+        | declaration
         | external_function_definition
         | EXTENSION external_definition                                         // GCC, multiple __extension__ allowed, meaning unknown
 …
+                }
         | ASM '(' string_literal ')' ';'                                        // GCC, global assembler statement
+                {
+                        $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) );
+                }
+                { $$ = DeclarationNode::newAsmStmt( new StatementNode( build_asm( false, $3, 0 ) ) ); }
         | EXTERN STRINGliteral                                                          // C++-style linkage specifier
+                {
 …
+        ;
-attribute_opt:
-        // empty
-                { $$ = nullptr; }
-        | attribute
+        ;
 attribute:                                                                                              // GCC
         ATTRIBUTE '(' '(' attribute_name_list ')' ')'
 …
 // declaring an array of functions versus a pointer to an array of functions.
+paren_identifier:
+        identifier
+                { $$ = DeclarationNode::newName( $1 ); }
+        | '(' paren_identifier ')'                                                      // redundant parenthesis
+                { $$ = $2; }
+        ;
 variable_declarator:
         paren_identifier attribute_list_opt
 …
+        ;
-paren_identifier:
-        identifier
-                { $$ = DeclarationNode::newName( $1 ); }
-        | '(' paren_identifier ')'                                                      // redundant parenthesis
-                { $$ = $2; }
+        ;
 variable_ptr:
         ptrref_operator variable_declarator
 …
         | ptrref_operator type_qualifier_list variable_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
+        | '(' variable_ptr ')' attribute_list_opt
+                { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
+        | '(' variable_ptr ')' attribute_list_opt                       // redundant parenthesis
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list variable_ptr ')' attribute_list_opt // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
 …
         | '(' variable_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
+        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
+        | '(' attribute_list variable_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
+        | '(' variable_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list variable_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' variable_array ')'                                                        // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list variable_array ')'                         // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         '(' variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list variable_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' variable_function ')'                                                     // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list variable_function ')'                      // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         | '(' function_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list function_ptr ')' '(' push parameter_type_list_opt pop ')'
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' function_no_ptr ')'                                                       // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list function_no_ptr ')'                        // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         | ptrref_operator type_qualifier_list function_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
+        | '(' function_ptr ')'
+                { $$ = $2; }
+        | '(' function_ptr ')' attribute_list_opt
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list function_ptr ')' attribute_list_opt
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
 …
         '(' function_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' function_array ')' multi_array_dimension          // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list function_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' function_array ')'                                                        // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list function_array ')'                         // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         | '(' KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list KR_function_ptr ')' '(' push parameter_type_list_opt pop ')'
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' KR_function_no_ptr ')'                                            // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list KR_function_no_ptr ')'                     // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         | '(' KR_function_ptr ')'
                 { $$ = $2; }
+        | '(' attribute_list KR_function_ptr ')'
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         '(' KR_function_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list KR_function_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' KR_function_array ')' multi_array_dimension       // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list KR_function_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' KR_function_array ')'                                                     // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list KR_function_array ')'                      // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
 // The pattern precludes declaring an array of functions versus a pointer to an array of functions, and returning arrays
 // and functions versus pointers to arrays and functions.
+paren_type:
+        typedef_name
+                {
+                        // hide type name in enclosing scope by variable name
+                        typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
+                }
+        | '(' paren_type ')'
+                { $$ = $2; }
+        ;
 variable_type_redeclarator:
 …
+        ;
-paren_type:
-        typedef
-                // hide type name in enclosing scope by variable name
+                {
-                        // if ( ! typedefTable.existsCurr( *$1->name ) ) {
-                                typedefTable.addToEnclosingScope( *$1->name, IDENTIFIER, "ID" );
-                        // } else {
-                        //      SemanticError( yylloc, string("'") + *$1->name + "' redeclared as different kind of symbol." ); $$ = nullptr;
-                        // } // if
+                }
-        | '(' paren_type ')'
-                { $$ = $2; }
+        ;
 type_ptr:
         ptrref_operator variable_type_redeclarator
 …
         | ptrref_operator type_qualifier_list variable_type_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
+        | '(' type_ptr ')' attribute_list_opt
+                { $$ = $2->addQualifiers( $4 ); }                               // redundant parenthesis
+        | '(' type_ptr ')' attribute_list_opt                           // redundant parenthesis
+                { $$ = $2->addQualifiers( $4 ); }
+        | '(' attribute_list type_ptr ')' attribute_list_opt // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addQualifiers( $5 ); }
+        ;
 …
         | '(' type_ptr ')' array_dimension
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list type_ptr ')' array_dimension
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')' multi_array_dimension                      // redundant parenthesis
                 { $$ = $2->addArray( $4 ); }
+        | '(' attribute_list type_array ')' multi_array_dimension // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 )->addArray( $5 ); }
         | '(' type_array ')'                                                            // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list type_array ')'                                     // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         | '(' type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $2->addParamList( $6 ); }
+        | '(' attribute_list type_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
+                { $$ = $3->addQualifiers( $2 )->addParamList( $7 ); }
         | '(' type_function ')'                                                         // redundant parenthesis
                 { $$ = $2; }
+        | '(' attribute_list type_function ')'                          // redundant parenthesis
+                { $$ = $3->addQualifiers( $2 ); }
+        ;
 …
         | ptrref_operator type_qualifier_list identifier_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' identifier_parameter_ptr ')' attribute_list_opt
+        | '(' identifier_parameter_ptr ')' attribute_list_opt // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
+        ;
 …
 type_parameter_redeclarator:
         typedef attribute_list_opt
+        typedef_name attribute_list_opt
                 { $$ = $1->addQualifiers( $2 ); }
         | '&' MUTEX typedef attribute_list_opt
+        | '&' MUTEX typedef_name attribute_list_opt
                 { $$ = $3->addPointer( DeclarationNode::newPointer( DeclarationNode::newTypeQualifier( Type::Mutex ), OperKinds::AddressOf ) )->addQualifiers( $4 ); }
         | type_parameter_ptr
 …
+        ;
 typedef:
+typedef_name:
         TYPEDEFname
                 { $$ = DeclarationNode::newName( $1 ); }
 …
         | ptrref_operator type_qualifier_list type_parameter_redeclarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' type_parameter_ptr ')' attribute_list_opt
+        | '(' type_parameter_ptr ')' attribute_list_opt         // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
+        ;
 type_parameter_array:
         typedef array_parameter_dimension
+        typedef_name array_parameter_dimension
                 { $$ = $1->addArray( $2 ); }
         | '(' type_parameter_ptr ')' array_parameter_dimension
 …
 type_parameter_function:
         typedef '(' push parameter_type_list_opt pop ')'        // empty parameter list OBSOLESCENT (see 3)
+        typedef_name '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
                 { $$ = $1->addParamList( $4 ); }
         | '(' type_parameter_ptr ')' '(' push parameter_type_list_opt pop ')' // empty parameter list OBSOLESCENT (see 3)
 …
         | ptrref_operator type_qualifier_list abstract_parameter_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' abstract_parameter_ptr ')' attribute_list_opt
+        | '(' abstract_parameter_ptr ')' attribute_list_opt     // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
+        ;
 …
         | ptrref_operator type_qualifier_list variable_abstract_declarator
                 { $$ = $3->addPointer( DeclarationNode::newPointer( $2, $1 ) ); }
         | '(' variable_abstract_ptr ')' attribute_list_opt
+        | '(' variable_abstract_ptr ')' attribute_list_opt      // redundant parenthesis
                 { $$ = $2->addQualifiers( $4 ); }
+        ;

src/ResolvExpr/CurrentObject.cc

-              rfeacef9
+              r5407cdc
                 if ( auto aggr = dynamic_cast< const BaseInstType * >( type ) ) {
                         if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
+                                assert( sit->base );
                                 return new StructIterator{ loc, sit };
                         } else if ( auto uit = dynamic_cast< const UnionInstType * >( aggr ) ) {
+                                assert( uit->base );
                                 return new UnionIterator{ loc, uit };
                         } else {

src/SynTree/Constant.cc

-              rfeacef9
+              r5407cdc
+}
+Constant Constant::from_string( const std::string & str ) {
+        Type * charType = new BasicType( noQualifiers, BasicType::Char );
+        // Adjust the length of the string for the terminator.
+        Expression * strSize = new ConstantExpr( Constant::from_ulong( str.size() + 1 ) );
+        Type * strType = new ArrayType( noQualifiers, charType, strSize, false, false );
+        const std::string strValue = "\"" + str + "\"";
+        return Constant( strType, strValue, std::nullopt );
+}
 Constant Constant::null( Type * ptrtype ) {
         if ( nullptr == ptrtype ) {

src/SynTree/Constant.h

rfeacef9	r5407cdc
47	47	/// generates an integer constant of the given unsigned long int
48	48	static Constant from_ulong( unsigned long i );
	49	/// generates a string constant from the given string (char type, unquoted string)
	50	static Constant from_string( const std::string & string );
49	51
50	52	/// generates a null pointer value for the given type. void * if omitted.

src/SynTree/Declaration.cc

-              rfeacef9
+              r5407cdc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 11 16:39:56 2019
 // Update Count     : 36
+// Last Modified On : Fri Mar 12 18:35:39 2021
+// Update Count     : 37
 //
 …
+DirectiveDecl::DirectiveDecl( DirectiveStmt *stmt ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), stmt( stmt ) {
+}
+DirectiveDecl::DirectiveDecl( const DirectiveDecl &other ) : Declaration( other ), stmt( maybeClone( other.stmt ) ) {
+}
+DirectiveDecl::~DirectiveDecl() {
+        delete stmt;
+}
+void DirectiveDecl::print( std::ostream &os, Indenter indent ) const {
+        stmt->print( os, indent );
+}
+void DirectiveDecl::printShort( std::ostream &os, Indenter indent ) const {
+        stmt->print( os, indent );
+}
 StaticAssertDecl::StaticAssertDecl( Expression * condition, ConstantExpr * message ) : Declaration( "", Type::StorageClasses(), LinkageSpec::C ), condition( condition ), message( message )  {
+}

src/SynTree/Declaration.h

-              rfeacef9
+              r5407cdc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 11 20:48:39 2021
 // Update Count     : 158
+// Last Modified On : Fri Mar 12 18:35:36 2021
+// Update Count     : 159
 //
 …
 };
+class DirectiveDecl : public Declaration {
+  public:
+        DirectiveStmt * stmt;
+        DirectiveDecl( DirectiveStmt * stmt );
+        DirectiveDecl( const DirectiveDecl & other );
+        virtual ~DirectiveDecl();
+        DirectiveStmt * get_stmt() { return stmt; }
+        void set_stmt( DirectiveStmt * newValue ) { stmt = newValue; }
+        virtual DirectiveDecl * clone() const override { return new DirectiveDecl( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual DirectiveDecl * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+        virtual void printShort( std::ostream & os, Indenter indent = {} ) const override;
+};
 class StaticAssertDecl : public Declaration {
 public:

src/SynTree/Mutator.h

-              rfeacef9
+              r5407cdc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 25 22:37:46 2019
 // Update Count     : 17
+// Last Modified On : Fri Mar 12 18:35:36 2021
+// Update Count     : 18
 //
 #pragma once
 …
         virtual Declaration * mutate( TypedefDecl * typeDecl ) = 0;
         virtual AsmDecl * mutate( AsmDecl * asmDecl ) = 0;
+        virtual DirectiveDecl * mutate( DirectiveDecl * directiveDecl ) = 0;
         virtual StaticAssertDecl * mutate( StaticAssertDecl * assertDecl ) = 0;

src/SynTree/SynTree.h

-              rfeacef9
+              r5407cdc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 25 22:37:45 2019
 // Update Count     : 12
+// Last Modified On : Fri Mar 12 18:56:44 2021
+// Update Count     : 13
 //
 …
 class TypedefDecl;
 class AsmDecl;
+class DirectiveDecl;
 class StaticAssertDecl;

src/SynTree/Visitor.h

-              rfeacef9
+              r5407cdc
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jul 25 22:21:49 2019
 // Update Count     : 14
+// Last Modified On : Fri Mar 12 18:35:35 2021
+// Update Count     : 15
 //
 …
         virtual void visit( AsmDecl * node ) { visit( const_cast<const AsmDecl *>(node) ); }
         virtual void visit( const AsmDecl * asmDecl ) = 0;
+        virtual void visit( DirectiveDecl * node ) { visit( const_cast<const DirectiveDecl *>(node) ); }
+        virtual void visit( const DirectiveDecl * directiveDecl ) = 0;
         virtual void visit( StaticAssertDecl * node ) { visit( const_cast<const StaticAssertDecl *>(node) ); }
         virtual void visit( const StaticAssertDecl * assertDecl ) = 0;

src/Virtual/ExpandCasts.cc

-              rfeacef9
+              r5407cdc
 namespace Virtual {
+static bool is_prefix( const std::string & prefix, const std::string& entire ) {
+        size_t const p_size = prefix.size();
+        return (p_size < entire.size() && prefix == entire.substr(0, p_size));
+}
+static bool is_type_id_object( const ObjectDecl * objectDecl ) {
+        const std::string & objectName = objectDecl->name;
+        return is_prefix( "__cfatid_", objectName );
+}
         // Indented until the new ast code gets added.
 …
         };
-        /* Currently virtual depends on the rather brittle name matching between
-         * a (strict/explicate) virtual type, its vtable type and the vtable
-         * instance.
-         * A stronger implementation, would probably keep track of those triads
-         * and use that information to create better error messages.
-         */
-        namespace {
-        std::string get_vtable_name( std::string const & name ) {
-                return name + "_vtable";
+        }
-        std::string get_vtable_inst_name( std::string const & name ) {
-                return std::string("_") + get_vtable_name( name ) + "_instance";
+        }
-        std::string get_vtable_name_root( std::string const & name ) {
-                return name.substr(0, name.size() - 7 );
+        }
-        std::string get_vtable_inst_name_root( std::string const & name ) {
-                return get_vtable_name_root( name.substr(1, name.size() - 10 ) );
+        }
-        bool is_vtable_inst_name( std::string const & name ) {
-                return 17 < name.size() &&
-                        name == get_vtable_inst_name( get_vtable_inst_name_root( name ) );
+        }
-        } // namespace
         class VirtualCastCore {
                 Type * pointer_to_pvt(int level_of_indirection) {
+                CastExpr * cast_to_type_id( Expression * expr, int level_of_indirection ) {
                         Type * type = new StructInstType(
                                 Type::Qualifiers( Type::Const ), pvt_decl );
 …
                                 type = new PointerType( noQualifiers, type );
+                        }
                         return type;
+                        return new CastExpr( expr, type );
+                }
 …
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
+                if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
+                        if ( ObjectDecl * existing = indexer.insert( objectDecl ) ) {
+                                std::string msg = "Repeated instance of virtual table, original found at: ";
+                                msg += existing->location.filename;
+                                msg += ":" + toString( existing->location.first_line );
+                                SemanticError( objectDecl->location, msg );
+                        }
+                if ( is_type_id_object( objectDecl ) ) {
+                        // Multiple definitions should be fine because of linkonce.
+                        indexer.insert( objectDecl );
+                }
+        }
 …
+        }
+        /// Get the virtual table type used in a virtual cast.
+        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
+                const Type * objectType;
+                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
+                        objectType = target->base;
+        /// Get the base type from a pointer or reference.
+        const Type * getBaseType( const Type * type ) {
+                if ( auto target = dynamic_cast<const PointerType *>( type ) ) {
+                        return target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( type ) ) {
+                        return target->base;
                 } else {
+                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
+                }
+                assert( objectType );
+                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
+                if ( nullptr == structType ) {
+                        castError( castExpr, "Virtual cast type must refer to a structure type." );
+                }
+                const StructDecl * structDecl = structType->baseStruct;
+                assert( structDecl );
+                const ObjectDecl * fieldDecl = nullptr;
+                if ( 0 < structDecl->members.size() ) {
+                        const Declaration * memberDecl = structDecl->members.front();
+                        return nullptr;
+                }
+        }
+        /* Attempt to follow the "head" field of the structure to get the...
+         * Returns nullptr on error, otherwise owner must free returned node.
+         */
+        StructInstType * followHeadPointerType(
+                        const StructInstType * oldType,
+                        const std::string& fieldName,
+                        const CodeLocation& errorLocation ) {
+                // First section of the function is all about trying to fill this variable in.
+                StructInstType * newType = nullptr;
+                {
+                        const StructDecl * oldDecl = oldType->baseStruct;
+                        assert( oldDecl );
+                        // Helper function for throwing semantic errors.
+                        auto throwError = [&fieldName, &errorLocation, &oldDecl](const std::string& message) {
+                                const std::string& context = "While following head pointer of " +
+                                        oldDecl->name + " named '" + fieldName + "': ";
+                                SemanticError( errorLocation, context + message );
+                        };
+                        if ( oldDecl->members.empty() ) {
+                                throwError( "Type has no fields." );
+                        }
+                        const Declaration * memberDecl = oldDecl->members.front();
                         assert( memberDecl );
+                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
+                                fieldDecl = nullptr;
+                        }
+                }
+                if ( nullptr == fieldDecl ) {
+                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
+                }
+                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
+                if ( nullptr == fieldType ) {
+                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
+                }
+                assert( fieldType->base );
+                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
+                assert( virtualStructType );
+                // Here is the type, but if it is polymorphic it will have lost information.
+                // (Always a clone so that it may always be deleted.)
+                StructInstType * virtualType = virtualStructType->clone();
+                if ( ! structType->parameters.empty() ) {
+                        deleteAll( virtualType->parameters );
+                        virtualType->parameters.clear();
+                        cloneAll( structType->parameters, virtualType->parameters );
+                }
+                return virtualType;
+                        const ObjectDecl * fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        assert( fieldDecl );
+                        if ( fieldName != fieldDecl->name ) {
+                                throwError( "Head field did not have expected name." );
+                        }
+                        const Type * fieldType = fieldDecl->type;
+                        if ( nullptr == fieldType ) {
+                                throwError( "Could not get head field." );
+                        }
+                        const PointerType * ptrType = dynamic_cast<const PointerType *>( fieldType );
+                        if ( nullptr == ptrType ) {
+                                throwError( "First field is not a pointer type." );
+                        }
+                        assert( ptrType->base );
+                        newType = dynamic_cast<StructInstType *>( ptrType->base );
+                        if ( nullptr == newType ) {
+                                throwError( "First field does not point to a structure type." );
+                        }
+                }
+                // Now we can look into copying it.
+                newType = newType->clone();
+                if ( ! oldType->parameters.empty() ) {
+                        deleteAll( newType->parameters );
+                        newType->parameters.clear();
+                        cloneAll( oldType->parameters, newType->parameters );
+                }
+                return newType;
+        }
+        /// Get the type-id type from a virtual type.
+        StructInstType * getTypeIdType( const Type * type, const CodeLocation& errorLocation ) {
+                const StructInstType * typeInst = dynamic_cast<const StructInstType *>( type );
+                if ( nullptr == typeInst ) {
+                        return nullptr;
+                }
+                StructInstType * tableInst =
+                        followHeadPointerType( typeInst, "virtual_table", errorLocation );
+                if ( nullptr == tableInst ) {
+                        return nullptr;
+                }
+                StructInstType * typeIdInst =
+                        followHeadPointerType( tableInst, "__cfavir_typeid", errorLocation );
+                delete tableInst;
+                return typeIdInst;
+        }
 …
                 assert( pvt_decl );
+                const Type * vtable_type = getVirtualTableType( castExpr );
+                ObjectDecl * table = indexer.lookup( vtable_type );
+                if ( nullptr == table ) {
+                        SemanticError( castLocation( castExpr ),
+                                "Could not find virtual table instance." );
+                const Type * base_type = getBaseType( castExpr->result );
+                if ( nullptr == base_type ) {
+                        castError( castExpr, "Virtual cast target must be a pointer or reference type." );
+                }
+                const Type * type_id_type = getTypeIdType( base_type, castLocation( castExpr ) );
+                if ( nullptr == type_id_type ) {
+                        castError( castExpr, "Ill formed virtual cast target type." );
+                }
+                ObjectDecl * type_id = indexer.lookup( type_id_type );
+                delete type_id_type;
+                if ( nullptr == type_id ) {
+                        castError( castExpr, "Virtual cast does not target a virtual type." );
+                }
                 Expression * result = new CastExpr(
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
+                                        new CastExpr(
+                                                new AddressExpr( new VariableExpr( table ) ),
+                                                pointer_to_pvt(1)
+                                        ),
+                                        new CastExpr(
+                                                castExpr->get_arg(),
+                                                pointer_to_pvt(2)
+                                        )
+                                cast_to_type_id( new AddressExpr( new VariableExpr( type_id ) ), 1 ),
+                                cast_to_type_id( castExpr->get_arg(), 2 ),
                         } ),
                         castExpr->get_result()->clone()
 …
                 castExpr->set_result( nullptr );
                 delete castExpr;
-                delete vtable_type;
                 return result;
+        }

src/Virtual/Tables.cc

-              rfeacef9
+              r5407cdc
 // Created On       : Mon Aug 31 11:11:00 2020
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Sep  3 14:56:00 2020
 // Update Count     : 0
+// Last Modified On : Wed Apr 21 15:36:00 2021
+// Update Count     : 2
 //
 …
 namespace Virtual {
+std::string typeIdType( std::string const & type_name ) {
+        return "__cfatid_struct_" + type_name;
+}
+std::string typeIdName( std::string const & type_name ) {
+        return "__cfatid_" + type_name;
+}
+static std::string typeIdTypeToInstance( std::string const & type_name ) {
+        return typeIdName(type_name.substr(16));
+}
 std::string vtableTypeName( std::string const & name ) {
         return name + "_vtable";
+}
+std::string baseTypeName( std::string const & vtable_type_name ) {
+        return vtable_type_name.substr(0, vtable_type_name.size() - 7);
+}
 std::string instanceName( std::string const & name ) {
         return std::string("_") + name + "_instance";
 …
 std::string vtableInstanceName( std::string const & name ) {
         return instanceName( vtableTypeName( name ) );
+}
+std::string concurrentDefaultVTableName() {
+        return "_default_vtable";
+}
 …
 static ObjectDecl * makeVtableDeclaration(
+                std::string const & name,
                 StructInstType * type, Initializer * init ) {
-        std::string const & name = instanceName( type->name );
         Type::StorageClasses storage = noStorageClasses;
         if ( nullptr == init ) {
 …
+}
 ObjectDecl * makeVtableForward( StructInstType * type ) {
+ObjectDecl * makeVtableForward( std::string const & name, StructInstType * type ) {
         assert( type );
         return makeVtableDeclaration( type, nullptr );
+        return makeVtableDeclaration( name, type, nullptr );
+}
 ObjectDecl * makeVtableInstance(
+                StructInstType * vtableType, Type * objectType, Initializer * init ) {
+                std::string const & name, StructInstType * vtableType,
+                Type * objectType, Initializer * init ) {
         assert( vtableType );
         assert( objectType );
 …
                                 inits.push_back(
                                                 new SingleInit( new AddressExpr( new NameExpr( parentInstance ) ) ) );
+                        } else if ( std::string( "__cfavir_typeid" ) == field->name ) {
+                                std::string const & baseType = baseTypeName( vtableType->name );
+                                std::string const & typeId = typeIdName( baseType );
+                                inits.push_back( new SingleInit( new AddressExpr( new NameExpr( typeId ) ) ) );
                         } else if ( std::string( "size" ) == field->name ) {
                                 inits.push_back( new SingleInit( new SizeofExpr( objectType->clone() ) ) );
 …
                 assert(false);
+        }
         return makeVtableDeclaration( vtableType, init );
+        return makeVtableDeclaration( name, vtableType, init );
+}
 …
+}
+}
+Attribute * linkonce( const std::string & subsection ) {
+        const std::string section = ".gnu.linkonce." + subsection;
+        return new Attribute( "section", {
+                new ConstantExpr( Constant::from_string( section ) ),
+        } );
+}
+ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType ) {
+        assert( typeIdType );
+        StructInstType * type = typeIdType->clone();
+        type->tq.is_const = true;
+        std::string const & typeid_name = typeIdTypeToInstance( typeIdType->name );
+        return new ObjectDecl(
+                typeid_name,
+                noStorageClasses,
+                LinkageSpec::Cforall,
+                /* bitfieldWidth */ nullptr,
+                type,
+                new ListInit( { new SingleInit(
+                        new AddressExpr( new NameExpr( "__cfatid_exception_t" ) )
+                        ) } ),
+                { linkonce( typeid_name ) },
+                noFuncSpecifiers
+        );
+}
+}

src/Virtual/Tables.h

-              rfeacef9
+              r5407cdc
 // Created On       : Mon Aug 31 11:07:00 2020
 // Last Modified By : Andrew Beach
 // Last Modified On : Tue Sep  1 14:29:00 2020
 // Update Count     : 0
+// Last Modified On : Wed Apr 21 10:30:00 2021
+// Update Count     : 2
 //
 …
 namespace Virtual {
+std::string typeIdType( std::string const & type_name );
+std::string typeIdName( std::string const & type_name );
 std::string vtableTypeName( std::string const & type_name );
 std::string instanceName( std::string const & vtable_name );
 std::string vtableInstanceName( std::string const & type_name );
+std::string concurrentDefaultVTableName();
 bool isVTableInstanceName( std::string const & name );
+ObjectDecl * makeVtableForward( StructInstType * vtableType );
+ObjectDecl * makeVtableForward(
+        std::string const & name, StructInstType * vtableType );
 /* Create a forward declaration of a vtable of the given type.
  * vtableType node is consumed.
  */
+ObjectDecl * makeVtableInstance( StructInstType * vtableType, Type * objectType,
+ObjectDecl * makeVtableInstance(
+        std::string const & name,
+        StructInstType * vtableType, Type * objectType,
         Initializer * init = nullptr );
 /* Create an initialized definition of a vtable.
 …
  */
+ObjectDecl * makeTypeIdInstance( StructInstType const * typeIdType );
+/* Build an instance of the type-id from the type of the type-id.
+ * TODO: Should take the parent type. Currently locked to the exception_t.
+ */
+}

src/main.cc

-              rfeacef9
+              r5407cdc
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Feb  8 21:10:16 2021
 // Update Count     : 642
+// Last Modified On : Sat Mar  6 15:49:00 2021
+// Update Count     : 656
 //
 …
 static string PreludeDirector = "";
 static void parse_cmdline( int argc, char *argv[] );
+static void parse_cmdline( int argc, char * argv[] );
 static void parse( FILE * input, LinkageSpec::Spec linkage, bool shouldExit = false );
 static void dump( list< Declaration * > & translationUnit, ostream & out = cout );
+static void dump( ast::TranslationUnit && transUnit, ostream & out = cout );
 static void backtrace( int start ) {                                    // skip first N stack frames
 …
 #define SIGPARMS int sig __attribute__(( unused )), siginfo_t * sfp __attribute__(( unused )), ucontext_t * cxt __attribute__(( unused ))
 static void Signal( int sig, void (*handler)(SIGPARMS), int flags ) {
+static void Signal( int sig, void (* handler)(SIGPARMS), int flags ) {
         struct sigaction act;
 …
         if ( sigaction( sig, &act, nullptr ) == -1 ) {
             cerr << "*CFA runtime error* problem installing signal handler, error(" << errno << ") " << strerror( errno ) << endl;
+            cerr << "*cfa-cpp compilation error* problem installing signal handler, error(" << errno << ") " << strerror( errno ) << endl;
             _exit( EXIT_FAILURE );
         } // if
 …
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
                         if ( exprp ) {
+                                translationUnit = convert( move( transUnit ) );
+                                dump( translationUnit );
+                                dump( move( transUnit ) );
                                 return EXIT_SUCCESS;
                         } // if
 …
                         delete output;
                 } // if
         } catch ( SemanticErrorException &e ) {
+        } catch ( SemanticErrorException & e ) {
                 if ( errorp ) {
                         cerr << "---AST at error:---" << endl;
 …
                 } // if
                 return EXIT_FAILURE;
         } catch ( UnimplementedError &e ) {
+        } catch ( UnimplementedError & e ) {
                 cout << "Sorry, " << e.get_what() << " is not currently implemented" << endl;
                 if ( output != &cout ) {
 …
                 } // if
                 return EXIT_FAILURE;
         } catch ( CompilerError &e ) {
+        } catch ( CompilerError & e ) {
                 cerr << "Compiler Error: " << e.get_what() << endl;
                 cerr << "(please report bugs to [REDACTED])" << endl;
 …
                 } // if
                 return EXIT_FAILURE;
+        } catch ( std::bad_alloc & ) {
+                cerr << "*cfa-cpp compilation error* std::bad_alloc" << endl;
+                backtrace( 1 );
+                abort();
         } catch ( ... ) {
                 exception_ptr eptr = current_exception();
 …
                                 rethrow_exception(eptr);
                         } else {
                                 cerr << "Exception Uncaught and Unknown" << endl;
                         } // if
                 } catch(const exception& e) {
                         cerr << "Uncaught Exception \"" << e.what() << "\"\n";
+                                cerr << "*cfa-cpp compilation error* exception uncaught and unknown" << endl;
+                        } // if
+                } catch( const exception & e ) {
+                        cerr << "*cfa-cpp compilation error* uncaught exception \"" << e.what() << "\"\n";
                 } // try
                 return EXIT_FAILURE;
 …
 enum { printoptsSize = sizeof( printopts ) / sizeof( printopts[0] ) };
 static void usage( char *argv[] ) {
+static void usage( char * argv[] ) {
     cout << "Usage: " << argv[0] << " [options] [input-file (default stdin)] [output-file (default stdout)], where options are:" << endl;
         int i = 0, j = 1;                                                                       // j skips starting colon
 …
 } // dump
+static void dump( ast::TranslationUnit && transUnit, ostream & out ) {
+        std::list< Declaration * > translationUnit = convert( move( transUnit ) );
+        dump( translationUnit, out );
+}
 // Local Variables: //
 // tab-width: 4 //

tests/.expect/KRfunctions.nast.arm64.txt

rfeacef9	r5407cdc
104	104	signed int _X1bi_2;
105	105	{
106		signed int (_tmp_cp_ret4)(signed int __param_0, signed int __param_1);
107		((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret~~4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4~~)));
	106	signed int (_tmp_cp_ret6)(signed int __param_0, signed int __param_1);
	107	((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret6=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret6)));
108	108	}
109	109

tests/.expect/KRfunctions.nast.x64.txt

rfeacef9	r5407cdc
104	104	signed int _X1bi_2;
105	105	{
106		signed int (_tmp_cp_ret4)(signed int __param_0, signed int __param_1);
107		((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret~~4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4~~)));
	106	signed int (_tmp_cp_ret6)(signed int __param_0, signed int __param_1);
	107	((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret6=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret6)));
108	108	}
109	109

tests/.expect/KRfunctions.nast.x86.txt

rfeacef9	r5407cdc
104	104	signed int _X1bi_2;
105	105	{
106		signed int (_tmp_cp_ret4)(signed int __param_0, signed int __param_1);
107		((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret~~4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4~~)));
	106	signed int (_tmp_cp_ret6)(signed int __param_0, signed int __param_1);
	107	((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret6=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret6)));
108	108	}
109	109

tests/.expect/KRfunctions.oast.x64.txt

rfeacef9	r5407cdc
104	104	signed int _X1bi_2;
105	105	{
106		signed int (_tmp_cp_ret4)(signed int _X1xi_1, signed int _X1yi_1);
107		((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret~~4=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret4~~)));
	106	signed int (_tmp_cp_ret6)(signed int _X1xi_1, signed int _X1yi_1);
	107	((void)(_X1xFPi_ii__2=(((void)(_tmp_cp_ret6=_X3f10FFPi_ii__iPiPid__1(3, (&_X1ai_2), (&_X1bi_2), 3.5))) , _tmp_cp_ret6)));
108	108	}
109	109

tests/.expect/attributes.nast.arm64.txt

-              rfeacef9
+              r5407cdc
+}
 struct __attribute__ ((unused)) __anonymous0 {
+struct __anonymous0 {
 };
 static inline void _X12_constructorFv_S12__anonymous0_autogen___1(struct __anonymous0 *_X4_dstS12__anonymous0_1);
 …
     return _X4_retS12__anonymous0_1;
+}
+__attribute__ ((unused)) struct __anonymous0 _X5DummyS12__anonymous0_1;
 struct __attribute__ ((unused)) Agn1;
 struct __attribute__ ((unused)) Agn2 {
 …
     __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
     __attribute__ ((used,used,unused)) signed int _X2f8i_1;
+    __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused,used)) signed int *_X3f10Pi_1;
+    __attribute__ ((unused,unused)) signed int *_X3f11Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1;
 };
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
 …
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1);
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1);
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ^?{} */);
+    }
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
 …
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1));
+    }
+    {
         ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
+    }
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
 …
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1){
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
 …
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X3f14Pi_1) /* ?{} */);
+    }
 …
 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
+__attribute__ ((used,used,used,used)) const signed int (*_X3vd9Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*_X4vd10Fi___1)();
 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
 __attribute__ ((unused)) signed int _X2f1Fi___1(){
 …
+}
 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
+__attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __param_0);
+__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __param_0);
+__attribute__ ((unused,used,unused,unused)) signed int (*_X2f4FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,unused)) signed int (*_X2f5FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f5PA0i_1)[];
+}
+__attribute__ ((unused,unused)) signed int (*_X2f6FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f6PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f7FFi_i____1())(signed int __param_0);
+__attribute__ ((unused,unused)) signed int (*_X2f8FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f8Fi_i__1)(signed int __param_0);
+}
+__attribute__ ((unused,unused)) signed int (*_X2f9FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f9Fi_i__1)(signed int __param_0);
+}
+__attribute__ ((unused,unused)) signed int (*_X3f10FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X11_retval_f10Fi_i__1)(signed int __param_0);
+}
 signed int _X3vtrFi___1(){
 …
     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
+    __attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X2t5A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t6Fi___2();
     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
+}
 …
 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned long int )5)]));
+signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object2)(signed int __param_0[((unsigned long int )5)]));
 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object2)(signed int (*__param_0)(signed int __param_0)));
+signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object3)(signed int (*__param_0)(signed int __param_0)));
 signed int _X2adFi___1(){
     __attribute__ ((unused)) signed int _X10_retval_adi_1;
 …
+}
 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object3, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object4);
 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object5, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object6);
 signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object7, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object8);
 signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object9)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object10)());
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object11)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0));
+signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object4, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object5);
+signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object6, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object7);
+signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object8, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object9);
+signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object10)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object11)());
+signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
+signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.nast.x64.txt

-              rfeacef9
+              r5407cdc
     __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
     __attribute__ ((used,used,unused)) signed int _X2f8i_1;
+    __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused,used)) signed int *_X3f10Pi_1;
+    __attribute__ ((unused,unused)) signed int *_X3f11Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1;
 };
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
 …
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1);
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1);
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ^?{} */);
+    }
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
 …
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1));
+    }
+    {
         ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
+    }
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
 …
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1){
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
 …
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X3f14Pi_1) /* ?{} */);
+    }
 …
 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
+__attribute__ ((used,used,used,used)) const signed int (*_X3vd9Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*_X4vd10Fi___1)();
 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
 __attribute__ ((unused)) signed int _X2f1Fi___1(){
 …
+}
 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
+__attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __param_0);
+__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __param_0);
+__attribute__ ((unused,used,unused,unused)) signed int (*_X2f4FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,unused)) signed int (*_X2f5FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f5PA0i_1)[];
+}
+__attribute__ ((unused,unused)) signed int (*_X2f6FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f6PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f7FFi_i____1())(signed int __param_0);
+__attribute__ ((unused,unused)) signed int (*_X2f8FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f8Fi_i__1)(signed int __param_0);
+}
+__attribute__ ((unused,unused)) signed int (*_X2f9FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f9Fi_i__1)(signed int __param_0);
+}
+__attribute__ ((unused,unused)) signed int (*_X3f10FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X11_retval_f10Fi_i__1)(signed int __param_0);
+}
 signed int _X3vtrFi___1(){
 …
     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
+    __attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X2t5A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t6Fi___2();
     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
+}
 …
 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned long int )5)]));
+signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object2)(signed int __param_0[((unsigned long int )5)]));
 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object2)(signed int (*__param_0)(signed int __param_0)));
+signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object3)(signed int (*__param_0)(signed int __param_0)));
 signed int _X2adFi___1(){
     __attribute__ ((unused)) signed int _X10_retval_adi_1;
 …
+}
 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object3, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object4);
 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object5, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object6);
 signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object7, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object8);
 signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object9)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object10)());
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object11)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0));
+signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object4, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object5);
+signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object6, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object7);
+signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object8, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object9);
+signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object10)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object11)());
+signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
+signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.nast.x86.txt

-              rfeacef9
+              r5407cdc
     __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
     __attribute__ ((used,used,unused)) signed int _X2f8i_1;
+    __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused,used)) signed int *_X3f10Pi_1;
+    __attribute__ ((unused,unused)) signed int *_X3f11Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1;
 };
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
 …
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1);
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1);
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ^?{} */);
+    }
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
 …
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1));
+    }
+    {
         ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
+    }
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
 …
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1){
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
 …
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X3f14Pi_1) /* ?{} */);
+    }
 …
 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
+__attribute__ ((used,used,used,used)) const signed int (*_X3vd9Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*_X4vd10Fi___1)();
 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
 __attribute__ ((unused)) signed int _X2f1Fi___1(){
 …
+}
 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
+__attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __param_0);
+__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __param_0);
+__attribute__ ((unused,used,unused,unused)) signed int (*_X2f4FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,unused)) signed int (*_X2f5FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f5PA0i_1)[];
+}
+__attribute__ ((unused,unused)) signed int (*_X2f6FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f6PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f7FFi_i____1())(signed int __param_0);
+__attribute__ ((unused,unused)) signed int (*_X2f8FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f8Fi_i__1)(signed int __param_0);
+}
+__attribute__ ((unused,unused)) signed int (*_X2f9FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X10_retval_f9Fi_i__1)(signed int __param_0);
+}
+__attribute__ ((unused,unused)) signed int (*_X3f10FFi_i____1())(signed int __param_0){
+    __attribute__ ((unused)) signed int (*_X11_retval_f10Fi_i__1)(signed int __param_0);
+}
 signed int _X3vtrFi___1(){
 …
     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
+    __attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X2t5A0PPi_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t6Fi___2();
     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
+}
 …
 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object1)(signed int __param_0[((unsigned int )5)]));
+signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object2)(signed int __param_0[((unsigned int )5)]));
 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object2)(signed int (*__param_0)(signed int __param_0)));
+signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object3)(signed int (*__param_0)(signed int __param_0)));
 signed int _X2adFi___1(){
     __attribute__ ((unused)) signed int _X10_retval_adi_1;
 …
+}
 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object3, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object4);
 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object5, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object6);
 signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object7, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object8);
 signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object9)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object10)());
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object11)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0));
+signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object4, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object5);
+signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object6, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object7);
+signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object8, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object9);
+signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object10)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object11)());
+signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object12)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object13)(signed int __param_0));
+signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object14)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)());
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)(signed int __param_0), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(signed int __param_0));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.oast.x64.txt

-              rfeacef9
+              r5407cdc
     __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
     __attribute__ ((used,used,unused)) signed int _X2f8i_1;
+    __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused,used)) signed int *_X3f10Pi_1;
+    __attribute__ ((unused,unused)) signed int *_X3f11Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1;
 };
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
 …
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1);
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1);
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ^?{} */);
+    }
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
 …
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1));
+    }
+    {
         ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
+    }
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
 …
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1){
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
 …
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X3f14Pi_1) /* ?{} */);
+    }
 …
 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
+__attribute__ ((used,used,used,used)) const signed int (*_X3vd9Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*_X4vd10Fi___1)();
 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
 __attribute__ ((unused)) signed int _X2f1Fi___1(){
 …
+}
 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
+__attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object1);
+__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object2){
+    __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
+__attribute__ ((unused,used,unused,unused)) signed int (*_X2f4FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,unused)) signed int (*_X2f5FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f5PA0i_1)[];
+}
+__attribute__ ((unused,unused)) signed int (*_X2f6FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f6PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f7FFi_i____1())(signed int __anonymous_object2);
+__attribute__ ((unused,unused)) signed int (*_X2f8FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object3){
+    __attribute__ ((unused)) signed int (*_X10_retval_f8Fi_i__1)(signed int __anonymous_object4);
+}
+__attribute__ ((unused,unused)) signed int (*_X2f9FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object5){
+    __attribute__ ((unused)) signed int (*_X10_retval_f9Fi_i__1)(signed int __anonymous_object6);
+}
+__attribute__ ((unused,unused)) signed int (*_X3f10FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*_X11_retval_f10Fi_i__1)(signed int __anonymous_object8);
+}
 signed int _X3vtrFi___1(){
 …
     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned long int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
+    __attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X2t5A0PPi_2[((unsigned long int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t6Fi___2();
     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
+}
 …
 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object4)(__attribute__ ((unused,unused)) signed int __anonymous_object5[((unsigned long int )5)]));
+signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned long int )5)]));
 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object6)(__attribute__ ((unused)) signed int (*__anonymous_object7)(__attribute__ ((unused,unused)) signed int __anonymous_object8)));
+signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
 signed int _X2adFi___1(){
     __attribute__ ((unused)) signed int _X10_retval_adi_1;
 …
+}
 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object11, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12);
 signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object13, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object14);
 signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)());
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __anonymous_object18), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object19)(__attribute__ ((unused)) signed int __anonymous_object20));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
+signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
+signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
+signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
+signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/attributes.oast.x86.txt

-              rfeacef9
+              r5407cdc
     __attribute__ ((used,unused,unused)) signed int _X2f7i_1;
     __attribute__ ((used,used,unused)) signed int _X2f8i_1;
+    __attribute__ ((unused,unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused)) signed int *_X2f9Pi_1;
+    __attribute__ ((unused,used)) signed int *_X3f10Pi_1;
+    __attribute__ ((unused,unused)) signed int *_X3f11Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1;
+    __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1;
 };
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1);
 …
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1);
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1);
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1);
 static inline void _X12_constructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3FdlS3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1, struct Fdl _X4_srcS3Fdl_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X11_destructorFv_S3Fdl_autogen___1(struct Fdl *_X4_dstS3Fdl_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ^?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ^?{} */);
+    }
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1) /* ^?{} */);
 …
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X4_srcS3Fdl_1._X3f10Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X4_srcS3Fdl_1._X3f11Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X4_srcS3Fdl_1._X3f12Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X4_srcS3Fdl_1._X3f13Pi_1));
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X4_srcS3Fdl_1._X3f14Pi_1));
+    }
+    {
         ((void)_X12_constructorFv_S3FdlS3Fdl_autogen___1((&_X4_retS3Fdl_1), (*_X4_dstS3Fdl_1)));
+    }
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdlii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1){
 …
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
 static inline void _X12_constructorFv_S3Fdliiiiiiii_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1){
 …
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused,unused)) signed int *_X2f9Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1){
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
 …
+    {
         ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1) /* ?{} */);
+    }
+}
+static inline void _X12_constructorFv_S3FdliiiiiiiiPiPiPiPiPiPi_autogen___1(struct Fdl *_X4_dstS3Fdl_1, __attribute__ ((unused)) signed int _X2f1i_1, __attribute__ ((unused)) signed int _X2f2i_1, __attribute__ ((unused,unused)) signed int _X2f3i_1, __attribute__ ((unused)) signed int _X2f4i_1, __attribute__ ((unused,unused)) signed int _X2f5i_1, signed int _X2f6i_1, __attribute__ ((unused,unused)) signed int _X2f7i_1, __attribute__ ((unused)) signed int _X2f8i_1, __attribute__ ((unused)) signed int *_X2f9Pi_1, __attribute__ ((unused)) signed int *_X3f10Pi_1, __attribute__ ((unused,unused)) signed int *_X3f11Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f12Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f13Pi_1, __attribute__ ((unused,unused,unused)) signed int *_X3f14Pi_1){
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f1i_1=_X2f1i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f2i_1=_X2f2i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f3i_1=_X2f3i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f4i_1=_X2f4i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f5i_1=_X2f5i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f6i_1=_X2f6i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f7i_1=_X2f7i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f8i_1=_X2f8i_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X2f9Pi_1=_X2f9Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f10Pi_1=_X3f10Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f11Pi_1=_X3f11Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f12Pi_1=_X3f12Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f13Pi_1=_X3f13Pi_1) /* ?{} */);
+    }
+    {
+        ((void)((*_X4_dstS3Fdl_1)._X3f14Pi_1=_X3f14Pi_1) /* ?{} */);
+    }
 …
 __attribute__ ((used,used,used,used)) const signed int (*_X3vd7Fi___1)();
 __attribute__ ((used,used,unused,used,used)) const signed int (*_X3vd8Fi___1)();
+__attribute__ ((used,used,used,used)) const signed int (*_X3vd9Fi___1)();
+__attribute__ ((used,used,unused,used,used)) const signed int (*_X4vd10Fi___1)();
 __attribute__ ((unused,used)) signed int _X2f1Fi___1();
 __attribute__ ((unused)) signed int _X2f1Fi___1(){
 …
+}
 __attribute__ ((unused,used,unused)) signed int (*_X2f3FPA0i_i__1(signed int __anonymous_object0))[];
+__attribute__ ((unused,unused)) signed int (*_X2f3FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f3PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f4FFi_i____1())(signed int __anonymous_object1);
+__attribute__ ((unused,unused)) signed int (*_X2f4FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object2){
+    __attribute__ ((unused)) signed int (*_X10_retval_f4Fi_i__1)(signed int __anonymous_object3);
+__attribute__ ((unused,used,unused,unused)) signed int (*_X2f4FPA0i_i__1(signed int __anonymous_object1))[];
+__attribute__ ((unused,unused)) signed int (*_X2f5FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f5PA0i_1)[];
+}
+__attribute__ ((unused,unused)) signed int (*_X2f6FPA0i_i__1(signed int _X1pi_1))[]{
+    __attribute__ ((unused)) signed int (*_X10_retval_f6PA0i_1)[];
+}
+__attribute__ ((unused,used,unused)) signed int (*_X2f7FFi_i____1())(signed int __anonymous_object2);
+__attribute__ ((unused,unused)) signed int (*_X2f8FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object3){
+    __attribute__ ((unused)) signed int (*_X10_retval_f8Fi_i__1)(signed int __anonymous_object4);
+}
+__attribute__ ((unused,unused)) signed int (*_X2f9FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object5){
+    __attribute__ ((unused)) signed int (*_X10_retval_f9Fi_i__1)(signed int __anonymous_object6);
+}
+__attribute__ ((unused,unused)) signed int (*_X3f10FFi_i____1())(__attribute__ ((unused)) signed int __anonymous_object7){
+    __attribute__ ((unused)) signed int (*_X11_retval_f10Fi_i__1)(signed int __anonymous_object8);
+}
 signed int _X3vtrFi___1(){
 …
     __attribute__ ((unused,unused,unused)) signed int _X2t3A0i_2[((unsigned int )5)];
     __attribute__ ((unused,unused,unused,unused,unused)) signed int **_X2t4A0PPi_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t5Fi___2();
+    __attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X2t5A0PPi_2[((unsigned int )5)];
+    __attribute__ ((unused,unused,unused)) signed int _X2t6Fi___2();
     __attribute__ ((unused,unused,unused,unused)) signed int *_X2t6FPi___2();
+}
 …
 signed int _X4tpr2Fi_PPi__1(__attribute__ ((unused,unused,unused,unused,unused,unused)) signed int **_X3FooPPi_1);
 signed int _X4tpr3Fi_Pi__1(__attribute__ ((unused,unused,unused)) signed int *_X3FooPi_1);
 signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object4)(__attribute__ ((unused,unused)) signed int __anonymous_object5[((unsigned int )5)]));
+signed int _X4tpr4Fi_Fi_Pi___1(__attribute__ ((unused,unused)) signed int (*__anonymous_object9)(__attribute__ ((unused,unused)) signed int __anonymous_object10[((unsigned int )5)]));
 signed int _X4tpr5Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr6Fi_Fi____1(__attribute__ ((unused,unused,unused)) signed int (*_X3FooFi___1)());
 signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object6)(__attribute__ ((unused)) signed int (*__anonymous_object7)(__attribute__ ((unused,unused)) signed int __anonymous_object8)));
+signed int _X4tpr7Fi_Fi_Fi_i____1(__attribute__ ((unused,unused)) signed int (*__anonymous_object11)(__attribute__ ((unused)) signed int (*__anonymous_object12)(__attribute__ ((unused,unused)) signed int __anonymous_object13)));
 signed int _X2adFi___1(){
     __attribute__ ((unused)) signed int _X10_retval_adi_1;
 …
+}
 signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object9, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object10);
 signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object11, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object12);
 signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object13, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object14);
 signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object15)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object16)());
 signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object17)(__attribute__ ((unused)) signed int __anonymous_object18), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object19)(__attribute__ ((unused)) signed int __anonymous_object20));
 signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)());
 signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object23)(__attribute__ ((unused)) signed int __anonymous_object24), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object25)(__attribute__ ((unused)) signed int __anonymous_object26));
+signed int _X4apd1Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object14, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object15);
+signed int _X4apd2Fi_PPiPPi__1(__attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object16, __attribute__ ((unused,unused,unused,unused)) signed int **__anonymous_object17);
+signed int _X4apd3Fi_PiPi__1(__attribute__ ((unused,unused,unused)) signed int *__anonymous_object18, __attribute__ ((unused,unused,unused)) signed int *__anonymous_object19);
+signed int _X4apd4Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object20)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object21)());
+signed int _X4apd5Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object22)(__attribute__ ((unused)) signed int __anonymous_object23), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object24)(__attribute__ ((unused)) signed int __anonymous_object25));
+signed int _X4apd6Fi_Fi__Fi____1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object26)(), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object27)());
+signed int _X4apd7Fi_Fi_i_Fi_i___1(__attribute__ ((unused,unused,unused)) signed int (*__anonymous_object28)(__attribute__ ((unused)) signed int __anonymous_object29), __attribute__ ((unused,unused,unused)) signed int (*__anonymous_object30)(__attribute__ ((unused)) signed int __anonymous_object31));
 struct Vad {
     __attribute__ ((unused)) signed int :4;

tests/.expect/declarationSpecifier.arm64.txt

rfeacef9	r5407cdc
1147	1147
1148	1148	{
1149		signed int _tmp_cp_ret4;
1150		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret~~4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4~~)) /* ?{} */);
	1149	signed int _tmp_cp_ret6;
	1150	((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6)) /* ?{} */);
1151	1151	}
1152	1152

tests/.expect/declarationSpecifier.x64.txt

rfeacef9	r5407cdc
1147	1147
1148	1148	{
1149		signed int _tmp_cp_ret4;
1150		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret~~4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4~~)) /* ?{} */);
	1149	signed int _tmp_cp_ret6;
	1150	((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6)) /* ?{} */);
1151	1151	}
1152	1152

tests/.expect/declarationSpecifier.x86.txt

rfeacef9	r5407cdc
1147	1147
1148	1148	{
1149		signed int _tmp_cp_ret4;
1150		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret~~4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4~~)) /* ?{} */);
	1149	signed int _tmp_cp_ret6;
	1150	((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6)) /* ?{} */);
1151	1151	}
1152	1152

tests/.expect/extension.arm64.txt

rfeacef9	r5407cdc
457	457
458	458	{
459		signed int _tmp_cp_ret4;
460		((void)(((void)(_tmp_cp_ret~~4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4~~));
	459	signed int _tmp_cp_ret6;
	460	((void)(((void)(_tmp_cp_ret6=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret6));
461	461	}
462	462

tests/.expect/extension.x64.txt

rfeacef9	r5407cdc
457	457
458	458	{
459		signed int _tmp_cp_ret4;
460		((void)(((void)(_tmp_cp_ret~~4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4~~));
	459	signed int _tmp_cp_ret6;
	460	((void)(((void)(_tmp_cp_ret6=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret6));
461	461	}
462	462

tests/.expect/extension.x86.txt

rfeacef9	r5407cdc
457	457
458	458	{
459		signed int _tmp_cp_ret4;
460		((void)(((void)(_tmp_cp_ret~~4=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret4~~));
	459	signed int _tmp_cp_ret6;
	460	((void)(((void)(_tmp_cp_ret6=__extension__ _X4fredFi_i__1(3))) , _tmp_cp_ret6));
461	461	}
462	462

tests/.expect/gccExtensions.arm64.txt

rfeacef9	r5407cdc
339	339
340	340	{
341		signed int _tmp_cp_ret4;
342		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret~~4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4~~)) /* ?{} */);
	341	signed int _tmp_cp_ret6;
	342	((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6)) /* ?{} */);
343	343	}
344	344

tests/.expect/gccExtensions.x64.txt

rfeacef9	r5407cdc
339	339
340	340	{
341		signed int _tmp_cp_ret4;
342		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret~~4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4~~)) /* ?{} */);
	341	signed int _tmp_cp_ret6;
	342	((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6)) /* ?{} */);
343	343	}
344	344

tests/.expect/gccExtensions.x86.txt

rfeacef9	r5407cdc
317	317
318	318	{
319		signed int _tmp_cp_ret4;
320		((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret~~4=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret4~~)) /* ?{} */);
	319	signed int _tmp_cp_ret6;
	320	((void)(_X12_retval_maini_1=(((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6)) /* ?{} */);
321	321	}
322	322

tests/Makefile.am

-              rfeacef9
+              r5407cdc
 ## Created On       : Sun May 31 09:08:15 2015
 ## Last Modified By : Peter A. Buhr
 ## Last Modified On : Fri Oct  9 23:13:07 2020
 ## Update Count     : 86
+## Last Modified On : Tue Mar  2 21:39:01 2021
+## Update Count     : 90
 ###############################################################################
 …
 archiveerrors=
 DEBUG_FLAGS=-debug -O0
+DEBUG_FLAGS=-debug -g -O0
 quick_test=avl_test operators numericConstants expression enum array typeof cast raii/dtor-early-exit raii/init_once attributes
 …
         -Wall \
         -Wno-unused-function \
         -quiet @CFA_FLAGS@ \
         -DIN_DIR="${abs_srcdir}/.in/"
+        -Wno-psabi \
+        -quiet @CFA_FLAGS@
 AM_CFAFLAGS = -XCFA --deterministic-out
 …
         pybin/tools.py \
         long_tests.hfa \
+        .in/io.data \
+        io/.in/io.data \
+        io/.in/many_read.data \
         avltree/avl.h \
         avltree/avl-private.h \
         concurrent/clib.c \
+        concurrent/clib_tls.c \
         exceptions/with-threads.hfa \
         exceptions/except-io.hfa
 …
 # don't use distcc to do the linking because distcc doesn't do linking
 % : %.cfa $(CFACCBIN)
         $(CFACOMPILETEST) -c -o $(abspath ${@}).o
+        $(CFACOMPILETEST) -c -o $(abspath ${@}).o -DIN_DIR="$(abspath $(dir ${<}))/.in/"
         $(CFACCLINK) ${@}.o -o $(abspath ${@})
         rm $(abspath ${@}).o
 …
 SYNTAX_ONLY_CODE = expression typedefRedef variableDeclarator switch numericConstants identFuncDeclarator forall \
         init1 limits nested-types stdincludes cast labelledExit array builtins/sync warnings/self-assignment
+        init1 limits nested-types stdincludes cast labelledExit array quasiKeyword include/includes builtins/sync warnings/self-assignment
 $(SYNTAX_ONLY_CODE): % : %.cfa $(CFACCBIN)
         $(CFACOMPILE_SYNTAX)

tests/attributes.cfa

-              rfeacef9
+              r5407cdc
 // Created On       : Mon Feb  6 16:07:02 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Jan 25 21:26:41 2021
 // Update Count     : 20
+// Last Modified On : Mon Mar 15 13:53:31 2021
+// Update Count     : 38
 //
 …
     __attribute__(( unused )) int f5 __attribute__(( unused ));
     __attribute__(( used )) int f6 __attribute__(( packed )), f7 __attribute__(( unused )) __attribute__(( unused )), __attribute__(( used )) f8 __attribute__(( unused ));
+    int ( ( * (f9) __attribute__(( unused )) ) __attribute__(( unused )) );
+    int * f9 __attribute__(( unused ));
+    __attribute__(( used )) int __attribute__(( unused )) * f10;
+    int ( ( * f11 __attribute__(( unused )) ) __attribute__(( unused )) );
+    int ( ( __attribute__(( unused )) * f12  __attribute__(( unused )) ) __attribute__(( unused )) );
+    int ( ( __attribute__(( unused )) * (f13)  __attribute__(( unused )) ) __attribute__(( unused )) );
+    int ( ( ( __attribute__(( unused )) * (f14) )  __attribute__(( unused )) ) __attribute__(( unused )) );
 };
 …
 const __attribute__(( used )) int __attribute__(( used )) vd5[5] __attribute__(( used )), __attribute__(( unused )) ((vd6)[5]) __attribute__(( used ));
 const __attribute__(( used )) int __attribute__(( used )) (* __attribute__(( used )) vd7)() __attribute__(( used )), __attribute__(( unused )) ((* __attribute__(( used )) vd8)()) __attribute__(( used ));
+const __attribute__(( used )) int __attribute__(( used )) ( __attribute__(( used )) * vd9)() __attribute__(( used )), __attribute__(( unused )) (( __attribute__(( used )) * vd10)()) __attribute__(( used ));
 // function_declarator
 …
 __attribute__(( unused )) int * __attribute__(( unused )) * const __attribute__(( unused )) f2() {}
 __attribute__(( unused )) int (* __attribute__(( unused )) f3(int))[] __attribute__(( used ));
+__attribute__(( unused )) int (* __attribute__(( unused )) f3(int p))[] {}
+__attribute__(( unused )) int (* __attribute__(( unused )) f4())(int) __attribute__(( used ));
+__attribute__(( unused )) int (* __attribute__(( unused )) f4())(int) {}
+__attribute__(( unused )) int ( __attribute__(( unused )) * __attribute__(( unused )) f4(int))[] __attribute__(( used ));
+__attribute__(( unused )) int (* __attribute__(( unused )) f5(int p))[] {}
+__attribute__(( unused )) int ( __attribute__(( unused )) * (f6)(int p))[] {}
+__attribute__(( unused )) int (* __attribute__(( unused )) f7())(int) __attribute__(( used ));
+__attribute__(( unused )) int (* __attribute__(( unused )) f8())(int) {}
+__attribute__(( unused )) int ( __attribute__(( unused )) * f9())(int) {}
+__attribute__(( unused )) int ( __attribute__(( unused )) * (f10)())(int) {}
 …
     __attribute__(( unused )) int __attribute__(( unused )) t3[5] __attribute__(( unused ));
     __attribute__(( unused )) int __attribute__(( unused )) (* (* __attribute__(( unused )) t4[5]) __attribute__(( unused )) ) __attribute__(( unused ));
+    __attribute__(( unused )) int __attribute__(( unused )) t5() __attribute__(( unused ));
+    __attribute__(( unused )) int __attribute__(( unused )) ( __attribute__(( unused )) * ( __attribute__(( unused )) * t5[5]) __attribute__(( unused )) ) __attribute__(( unused ));
+    __attribute__(( unused )) int __attribute__(( unused )) t6() __attribute__(( unused ));
     __attribute__(( unused )) int __attribute__(( unused )) * __attribute__(( unused )) ((t6))() __attribute__(( unused ));
+}

tests/concurrent/clib.c

-              rfeacef9
+              r5407cdc
-#include <clib/cfathread.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <clib/cfathread.h>
+#include <bits/defs.hfa>
+extern "C" {
+void _exit(int status);
+}
 thread_local struct drand48_data buffer = { 0 };
 …
 cfathread_t volatile blocked[blocked_size];
 void Worker( cfathread_t this ) {
+void * Worker( void * ) {
         for(int i = 0; i < 1000; i++) {
                 int idx = myrand() % blocked_size;
 …
                         cfathread_unpark( thrd );
                 } else {
                         cfathread_t thrd = __atomic_exchange_n(&blocked[idx], this, __ATOMIC_SEQ_CST);
+                        cfathread_t thrd = __atomic_exchange_n(&blocked[idx], cfathread_self(), __ATOMIC_SEQ_CST);
                         cfathread_unpark( thrd );
                         cfathread_park();
 …
+        }
         printf("Done\n");
+        return NULL;
+}
 volatile bool stop;
 void Unparker( cfathread_t this ) {
+void * Unparker( void * ) {
         while(!stop) {
                 int idx = myrand() % blocked_size;
 …
+        }
         printf("Done Unparker\n");
+        return NULL;
+}
 …
+        }
+        cfathread_setproccnt( 4 );
+        cfathread_t u = cfathread_create( Unparker );
+        cfathread_cluster_t cl = cfathread_cluster_self();
+        cfathread_cluster_add_worker( cl, NULL, NULL, NULL );
+        cfathread_cluster_add_worker( cl, NULL, NULL, NULL );
+        cfathread_cluster_add_worker( cl, NULL, NULL, NULL );
+        cfathread_attr_t attr;
+        cfathread_attr_init(&attr);
+        cfathread_attr_setcluster(&attr, cl);
+        cfathread_t u;
+        cfathread_create( &u, &attr, Unparker, NULL );
+        {
                 cfathread_t t[20];
                 for(int i = 0; i < 20; i++) {
                         t[i] = cfathread_create( Worker );
+                        cfathread_create( &t[i], &attr, Worker, NULL );
+                }
                 for(int i = 0; i < 20; i++) {
                         cfathread_join( t[i] );
+                        cfathread_join( t[i], NULL );
+                }
+        }
         stop = true;
+        cfathread_join(u);
+        cfathread_setproccnt( 1 );
+        cfathread_join(u, NULL);
+        cfathread_attr_destroy(&attr);
+        fflush(stdout);
+        _exit(0);
+}

tests/concurrent/coroutineYield.cfa

-              rfeacef9
+              r5407cdc
+Coroutine c;
 int main(int argc, char* argv[]) {
-        Coroutine c;
         for(int i = 0; TEST(i < N); i++) {
                 #if !defined(TEST_FOREVER)

tests/concurrent/futures/multi.cfa

-              rfeacef9
+              r5407cdc
 thread Server {
         int cnt, iteration;
+        int pending, done, iteration;
         multi_future(int) * request;
 };
 void ?{}( Server & this ) {
+        this.cnt = 0;
+        ((thread&)this){"Server Thread"};
+        this.pending = 0;
+        this.done = 0;
         this.iteration = 0;
         this.request = 0p;
 …
 void ^?{}( Server & mutex this ) {
         assert(this.cnt == 0);
     this.request = 0p;
+        assert(this.pending == 0);
+        this.request = 0p;
+}
 …
+}
+void process( Server & mutex this ) {
+        fulfil( *this.request, this.iteration );
+        this.iteration++;
+void call( Server & mutex this ) {
+        this.pending++;
+}
 void call( Server & mutex this ) {
         this.cnt++;
+void finish( Server & mutex this ) {
+        this.done++;
+}
-void finish( Server & mutex this ) { }
 void main( Server & this ) {
+        MAIN_LOOP:
         for() {
                 waitfor( ^?{} : this ) {
                         break;
+                }
+                or when( this.cnt < NFUTURES ) waitfor( call: this ) {
+                        if (this.cnt == NFUTURES) {
+                                process(this);
+                or waitfor( call: this ) {
+                        if (this.pending != NFUTURES) { continue MAIN_LOOP; }
+                        this.pending = 0;
+                        fulfil( *this.request, this.iteration );
+                        this.iteration++;
+                        for(NFUTURES) {
+                                waitfor( finish: this );
+                        }
+                }
+                or waitfor( finish: this ) {
+                        if (this.cnt == NFUTURES) {
+                                reset( *this.request );
+                                this.cnt = 0;
+                        }
+                        reset( *this.request );
+                        this.done = 0;
+                }
+        }
 …
 Server * the_server;
 thread Worker {};
+void ?{}(Worker & this) {
+        ((thread&)this){"Worker Thread"};
+}
 multi_future(int) * shared_future;

tests/errors/.expect/completeType.nast.arm64.txt

-              rfeacef9
+              r5407cdc
       Application of
         Variable Expression: *?: forall
           DT: data type
+          instance of type DT (not function type)
           function
         ... with parameters
 …
         ... with resolved type:
           pointer to forall
+            [unbound]:data type
+            instance of type [unbound] (not function type)
+            function
+          ... with parameters
+            pointer to instance of type [unbound] (not function type)
+          ... returning
+            reference to instance of type [unbound] (not function type)
+        ... to arguments
+        Variable Expression: x: pointer to instance of struct A without body
+        ... with resolved type:
+          pointer to instance of struct A without body
+      ... with resolved type:
+        reference to instance of struct A without body
+    ... to: nothing
+    ... with resolved type:
+      void
+  (types:
+    void
+  )
+  Environment:([unbound]DT) -> instance of struct A without body (no widening)
+Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
+      Application of
+        Variable Expression: *?: forall
+          instance of type DT (not function type)
+          function
+        ... with parameters
+          pointer to instance of type DT (not function type)
+        ... returning
+          reference to instance of type DT (not function type)
+        ... with resolved type:
+          pointer to forall
+            instance of type [unbound] (not function type)
             function
           ... with parameters
 …
     void
+  )
+  Environment:([unbound]) -> instance of struct B with body (no widening)
+Cost ( 0, 1, 2, 0, 1, -1, 0 ): Generated Cast of:
+      Application of
+        Variable Expression: *?: forall
+          DT: data type
+          function
+        ... with parameters
+          pointer to instance of type DT (not function type)
+        ... returning
+          reference to instance of type DT (not function type)
+        ... with resolved type:
+          pointer to forall
+            [unbound]:data type
+            function
+          ... with parameters
+            pointer to instance of type [unbound] (not function type)
+          ... returning
+            reference to instance of type [unbound] (not function type)
+        ... to arguments
+        Variable Expression: x: pointer to instance of struct A without body
+        ... with resolved type:
+          pointer to instance of struct A without body
+      ... with resolved type:
+        reference to instance of struct A without body
+    ... to: nothing
+    ... with resolved type:
+      void
+  (types:
+    void
+  )
+  Environment:([unbound]) -> instance of struct A without body (no widening)
+  Environment:([unbound]DT) -> instance of struct B with body (no widening)
 …
 Cost ( 0, 1, 0, 0, 1, -5, 0 ): Application of
             Variable Expression: baz: forall
+              T: sized data type
+              ... with assertions
+                ?=?: pointer to function
+              instance of type T (not function type)
+              with assertions
+              Variable Expression: ?=?: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+                instance of type T (not function type)
+              ... returning
+                instance of type T (not function type)
+              ... with resolved type:
+                pointer to function
                 ... with parameters
                   reference to instance of type T (not function type)
 …
                   instance of type T (not function type)
+                ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+                ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning nothing
+                ^?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+              Variable Expression: ?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+              Variable Expression: ?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+                instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning nothing
+              Variable Expression: ^?{}: pointer to function
+              ... with parameters
+                reference to instance of type T (not function type)
+              ... returning nothing
+              ... with resolved type:
+                pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
               function
 …
             ... with resolved type:
               pointer to forall
+                [unbound]:sized data type
+                ... with assertions
+                  ?=?: pointer to function
+                instance of type [unbound] (not function type)
+                with assertions
+                Variable Expression: ?=?: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning
+                  instance of type T (not function type)
+                ... with resolved type:
+                  pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
 …
                     instance of type [unbound] (not function type)
+                  ?{}: pointer to function
+                Variable Expression: ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
                   ... returning nothing
+                  ?{}: pointer to function
+                Variable Expression: ?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                  instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
 …
                   ... returning nothing
+                  ^?{}: pointer to function
+                Variable Expression: ^?{}: pointer to function
+                ... with parameters
+                  reference to instance of type T (not function type)
+                ... returning nothing
+                ... with resolved type:
+                  pointer to function
                   ... with parameters
                     reference to instance of type [unbound] (not function type)
                   ... returning nothing
                 function
 …
           void
+        )
         Environment:([unbound]) -> instance of type T (not function type) (no widening)
+        Environment:([unbound]T) -> instance of type T (not function type) (no widening)
       Could not satisfy assertion:
 ?=?: pointer to function
+Variable Expression: ?=?: pointer to function
         ... with parameters
           reference to instance of type [unbound] (not function type)
           instance of type [unbound] (not function type)
+          reference to instance of type T (not function type)
+          instance of type T (not function type)
         ... returning
+          instance of type [unbound] (not function type)
+          instance of type T (not function type)
+        ... with resolved type:
+          pointer to function
+          ... with parameters
+            reference to instance of type [unbound] (not function type)
+            instance of type [unbound] (not function type)
+          ... returning
+            instance of type [unbound] (not function type)

tests/exceptions/.expect/resume-threads.txt

-              rfeacef9
+              r5407cdc
 catch-all
-throwing child exception
-inner parent match
 caught yin as yin

tests/exceptions/.expect/resume.txt

-              rfeacef9
+              r5407cdc
 catch-all
-throwing child exception
-inner parent match
 caught yin as yin

tests/exceptions/.expect/terminate-threads.txt

-              rfeacef9
+              r5407cdc
 catch-all
-throwing child exception
-inner parent match
 caught yin as yin

tests/exceptions/.expect/terminate.txt

-              rfeacef9
+              r5407cdc
 catch-all
-throwing child exception
-inner parent match
 caught yin as yin

tests/exceptions/cancel/coroutine.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
+TRIVIAL_EXCEPTION(internal_error);
+EHM_EXCEPTION(internal_error)();
+EHM_VIRTUAL_TABLE(internal_error, internal_vt);
 coroutine WillCancel {};
 …
 void main(WillCancel & wc) {
         printf("1");
         cancel_stack((internal_error){});
+        cancel_stack((internal_error){&internal_vt});
         printf("!");
+}

tests/exceptions/cancel/thread.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
+TRIVIAL_EXCEPTION(internal_error);
+EHM_EXCEPTION(internal_error)();
+EHM_VIRTUAL_TABLE(internal_error, internal_vt);
 thread WillCancel {};
 …
 void main(WillCancel &) {
         printf("1");
         cancel_stack((internal_error){});
+        cancel_stack((internal_error){&internal_vt});
         printf("!");
+}

tests/exceptions/conditional.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
 VTABLE_DECLARATION(num_error)(
         int (*code)(num_error *this);
+EHM_EXCEPTION(num_error)(
+        int num;
 );
+struct num_error {
+        VTABLE_FIELD(num_error);
+    char * msg;
+    int num;
+};
+const char * num_error_msg(num_error * this) {
+    if ( ! this->msg ) {
+        static const char * base = "Num Error with code: X";
+        this->msg = (char *)malloc(22);
+        for (int i = 0 ; (this->msg[i] = base[i]) ; ++i);
+    }
+    this->msg[21] = '0' + this->num;
+    return this->msg;
+}
+void ?{}(num_error & this, int num) {
+        VTABLE_INIT(this, num_error);
+    this.msg = 0;
+    this.num = num;
+}
+void ?{}(num_error & this, num_error & other) {
+    this.virtual_table = other.virtual_table;
+    this.msg = 0;
+    this.num = other.num;
+}
+void ^?{}(num_error & this) {
+    if( this.msg ) free( this.msg );
+}
+int num_error_code( num_error * this ) {
+    return this->num;
+}
+VTABLE_INSTANCE(num_error)(
+        num_error_msg,
+        num_error_code,
+);
+EHM_VIRTUAL_TABLE(num_error, num_error_vt);
 void caught_num_error(int expect, num_error * actual) {
 …
 int main(int argc, char * argv[]) {
         num_error exc = 2;
+        num_error exc = {&num_error_vt, 2};
         try {
                 throw exc;
         } catch (num_error * error ; 3 == error->virtual_table->code( error )) {
+        } catch (num_error * error ; 3 == error->num ) {
                 caught_num_error(3, error);
         } catch (num_error * error ; 2 == error->virtual_table->code( error )) {
+        } catch (num_error * error ; 2 == error->num ) {
                 caught_num_error(2, error);
+        }
 …
         try {
                 throwResume exc;
         } catchResume (num_error * error ; 3 == error->virtual_table->code( error )) {
+        } catchResume (num_error * error ; 3 == error->num ) {
                 caught_num_error(3, error);
         } catchResume (num_error * error ; 2 == error->virtual_table->code( error )) {
+        } catchResume (num_error * error ; 2 == error->num ) {
                 caught_num_error(2, error);
+        }

tests/exceptions/data-except.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
 DATA_EXCEPTION(paired)(
+EHM_EXCEPTION(paired)(
         int first;
         int second;
 );
+void ?{}(paired & this, int first, int second) {
+        VTABLE_INIT(this, paired);
+        this.first = first;
+        this.second = second;
+}
+EHM_VIRTUAL_TABLE(paired, paired_vt);
+const char * paired_msg(paired * this) {
+        return "paired";
+}
+VTABLE_INSTANCE(paired)(paired_msg);
+void throwPaired(int first, int second) {
+        paired exc = {first, second};
+const char * virtual_msg(paired * this) {
+        return this->virtual_table->msg(this);
+}
 int main(int argc, char * argv[]) {
         paired except = {3, 13};
+        paired except = {&paired_vt, 3, 13};
         try {
                 throw except;
         } catch (paired * exc) {
                 printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
+                printf("%s(%d, %d)\n", virtual_msg(exc), exc->first, exc->second);
                 ++exc->first;
+        }
         printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second);
+        printf("%s(%d, %d)\n", virtual_msg(&except), except.first, except.second);
         try {
                 throwResume except;
         } catchResume (paired * exc) {
                 printf("%s(%d, %d)\n", paired_msg(exc), exc->first, exc->second);
+                printf("%s(%d, %d)\n", virtual_msg(exc), exc->first, exc->second);
                 ++exc->first;
+        }
         printf("%s(%d, %d)\n", paired_msg(&except), except.first, except.second);
+        printf("%s(%d, %d)\n", virtual_msg(&except), except.first, except.second);
+}

tests/exceptions/defaults.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
 DATA_EXCEPTION(log_message)(
+EHM_EXCEPTION(log_message)(
         char * msg;
 );
+void ?{}(log_message & this, char * msg) {
+        VTABLE_INIT(this, log_message);
+        this.msg = msg;
+}
+const char * get_log_message(log_message * this) {
+_EHM_DEFINE_COPY(log_message, )
+const char * msg(log_message * this) {
         return this->msg;
+}
+VTABLE_INSTANCE(log_message)(get_log_message);
+_EHM_VIRTUAL_TABLE(log_message, , log_vt);
 // Logging messages don't have to be handled.
 …
         // We can catch log:
         try {
                 throwResume (log_message){"Should be printed.\n"};
+                throwResume (log_message){&log_vt, "Should be printed.\n"};
         } catchResume (log_message * this) {
                 printf("%s", this->virtual_table->msg(this));
+        }
         // But we don't have to:
         throwResume (log_message){"Should not be printed.\n"};
+        throwResume (log_message){&log_vt, "Should not be printed.\n"};
+}
 // I don't have a good use case for doing the same with termination.
 TRIVIAL_EXCEPTION(jump);
+EHM_EXCEPTION(jump)();
 void defaultTerminationHandler(jump &) {
         printf("jump default handler.\n");
+}
+EHM_VIRTUAL_TABLE(jump, jump_vt);
 void jump_test(void) {
         try {
                 throw (jump){};
+                throw (jump){&jump_vt};
         } catch (jump * this) {
                 printf("jump catch handler.\n");
+        }
         throw (jump){};
+        throw (jump){&jump_vt};
+}
+TRIVIAL_EXCEPTION(first);
+TRIVIAL_EXCEPTION(unhandled_exception);
+EHM_EXCEPTION(first)();
+EHM_VIRTUAL_TABLE(first, first_vt);
+EHM_EXCEPTION(unhandled_exception)();
+EHM_VIRTUAL_TABLE(unhandled_exception, unhandled_vt);
 void unhandled_test(void) {
         forall(T &, V & | is_exception(T, V))
         void defaultTerminationHandler(T &) {
                 throw (unhandled_exception){};
+                throw (unhandled_exception){&unhandled_vt};
+        }
         void defaultTerminationHandler(unhandled_exception &) {
 …
+        }
         try {
                 throw (first){};
+                throw (first){&first_vt};
         } catch (unhandled_exception * t) {
                 printf("Catch unhandled_exception.\n");
 …
+}
+TRIVIAL_EXCEPTION(second);
+EHM_EXCEPTION(second)();
+EHM_VIRTUAL_TABLE(second, second_vt);
 void cross_test(void) {
         void defaultTerminationHandler(first &) {
                 printf("cross terminate default\n");
                 throw (second){};
+                throw (second){&second_vt};
+        }
         void defaultResumptionHandler(first &) {
                 printf("cross resume default\n");
                 throwResume (second){};
+                throwResume (second){&second_vt};
+        }
         try {
                 printf("cross terminate throw\n");
                 throw (first){};
+                throw (first){&first_vt};
         } catch (second *) {
                 printf("cross terminate catch\n");
 …
         try {
                 printf("cross resume throw\n");
                 throwResume (first){};
+                throwResume (first){&first_vt};
         } catchResume (second *) {
                 printf("cross resume catch\n");

tests/exceptions/finally.cfa

-              rfeacef9
+              r5407cdc
 #include "except-io.hfa"
+TRIVIAL_EXCEPTION(myth);
+EHM_EXCEPTION(myth)();
+EHM_VIRTUAL_TABLE(myth, myth_vt);
 int main(int argc, char * argv[]) {
         myth exc;
+        myth exc = {&myth_vt};
         try {

tests/exceptions/interact.cfa

-              rfeacef9
+              r5407cdc
 #include "except-io.hfa"
+TRIVIAL_EXCEPTION(star);
+TRIVIAL_EXCEPTION(moon);
+EHM_EXCEPTION(star)();
+EHM_EXCEPTION(moon)();
+EHM_VIRTUAL_TABLE(star, star_vt);
+EHM_VIRTUAL_TABLE(moon, moon_vt);
 int main(int argc, char * argv[]) {
         // Resume falls back to terminate.
         try {
                 throwResume (star){};
+                throwResume (star){&star_vt};
         } catch (star *) {
                 printf("caught as termination\n");
 …
         try {
                 loud_region a = "try block with resume throw";
                 throwResume (star){};
+                throwResume (star){&star_vt};
         } catch (star *) {
                 printf("caught as termination\n");
 …
         try {
                 try {
                         throw (star){};
+                        throw (star){&star_vt};
                 } catchResume (star *) {
                         printf("resume catch on terminate\n");
 …
         try {
                 try {
                         throwResume (star){};
+                        throwResume (star){&star_vt};
                 } catch (star *) {
                         printf("terminate catch on resume\n");
 …
                 try {
                         try {
                                 throw (star){};
+                                throw (star){&star_vt};
                         } catchResume (star *) {
                                 printf("inner resume catch (error)\n");
 …
                 try {
                         try {
                                 throwResume (star){};
+                                throwResume (star){&star_vt};
                         } catch (star *) {
                                 printf("inner termination catch\n");
 …
                                 try {
                                         printf("throwing resume moon\n");
                                         throwResume (moon){};
+                                        throwResume (moon){&moon_vt};
                                 } catch (star *) {
                                         printf("termination catch\n");
+                                }
                                 printf("throwing resume star\n");
                                 throwResume (star){};
+                                throwResume (star){&star_vt};
                         } catchResume (star *) {
                                 printf("resumption star catch\n");
 …
                 } catchResume (moon *) {
                         printf("resumption moon catch, will terminate\n");
                         throw (star){};
+                        throw (star){&star_vt};
+                }
         } catchResume (star *) {

tests/exceptions/polymorphic.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
+FORALL_TRIVIAL_EXCEPTION(proxy, (T), (T));
+FORALL_TRIVIAL_INSTANCE(proxy, (U), (U))
+EHM_FORALL_EXCEPTION(proxy, (T&), (T))();
+const char * msg(proxy(int) * this) { return "proxy(int)"; }
+const char * msg(proxy(char) * this) { return "proxy(char)"; }
+POLY_VTABLE_INSTANCE(proxy, int)(msg);
+POLY_VTABLE_INSTANCE(proxy, char)(msg);
+EHM_FORALL_VIRTUAL_TABLE(proxy, (int), proxy_int);
+EHM_FORALL_VIRTUAL_TABLE(proxy, (char), proxy_char);
 void proxy_test(void) {
+        proxy(int) an_int = {&proxy_int};
+        proxy(char) a_char = {&proxy_char};
     try {
                 throw (proxy(int)){};
+                throw an_int;
         } catch (proxy(int) *) {
                 printf("terminate catch\n");
 …
         try {
                 throwResume (proxy(char)){};
+                throwResume a_char;
         } catchResume (proxy(char) *) {
                 printf("resume catch\n");
 …
         try {
                 throw (proxy(char)){};
+                throw a_char;
         } catch (proxy(int) *) {
                 printf("caught proxy(int)\n");
 …
+}
 FORALL_DATA_EXCEPTION(cell, (T), (T))(
+EHM_FORALL_EXCEPTION(cell, (T), (T))(
         T data;
 );
+FORALL_DATA_INSTANCE(cell, (T), (T))
+const char * msg(cell(int) * this) { return "cell(int)"; }
+const char * msg(cell(char) * this) { return "cell(char)"; }
+const char * msg(cell(bool) * this) { return "cell(bool)"; }
+POLY_VTABLE_INSTANCE(cell, int)(msg);
+POLY_VTABLE_INSTANCE(cell, char)(msg);
+POLY_VTABLE_INSTANCE(cell, bool)(msg);
+EHM_FORALL_VIRTUAL_TABLE(cell, (int), int_cell);
+EHM_FORALL_VIRTUAL_TABLE(cell, (char), char_cell);
+EHM_FORALL_VIRTUAL_TABLE(cell, (bool), bool_cell);
 void cell_test(void) {
         try {
+                cell(int) except;
+                except.data = -7;
+                cell(int) except = {&int_cell, -7};
                 throw except;
         } catch (cell(int) * error) {
 …
         try {
+                cell(bool) ball;
+                ball.data = false;
+                cell(bool) ball = {&bool_cell, false};
                 throwResume ball;
                 printf("%i\n", ball.data);

tests/exceptions/resume.cfa

-              rfeacef9
+              r5407cdc
 #include "except-io.hfa"
+TRIVIAL_EXCEPTION(yin);
+TRIVIAL_EXCEPTION(yang);
+TRIVIAL_EXCEPTION(zen);
+TRIVIAL_EXCEPTION(moment_of, zen);
+EHM_EXCEPTION(yin)();
+EHM_EXCEPTION(yang)();
+EHM_EXCEPTION(zen)();
+EHM_VIRTUAL_TABLE(yin, yin_vt);
+EHM_VIRTUAL_TABLE(yang, yang_vt);
+EHM_VIRTUAL_TABLE(zen, zen_vt);
 void in_void(void);
 int main(int argc, char * argv[]) {
+        yin a_yin = {&yin_vt};
+        yang a_yang = {&yang_vt};
+        zen a_zen = {&zen_vt};
         // The simple throw catchResume test.
         try {
                 loud_exit a = "simple try clause";
                 printf("simple throw\n");
                 throwResume (zen){};
+                throwResume a_zen;
                 printf("end of try clause\n");
         } catchResume (zen * error) {
 …
         // Throw catch-all test.
         try {
                 throwResume (zen){};
+                throwResume a_zen;
         } catchResume (exception_t * error) {
                 printf("catch-all\n");
+        }
-        printf("\n");
-        // Catch a parent of the given exception.
-        try {
-                printf("throwing child exception\n");
-                throwResume (moment_of){};
-        } catchResume (zen *) {
-                printf("inner parent match\n");
-        } catchResume (moment_of *) {
-                printf("outer exact match\n");
+        }
         printf("\n");
 …
         try {
                 try {
                         throwResume (yin){};
+                        throwResume a_yin;
                 } catchResume (zen *) {
                         printf("caught yin as zen\n");
 …
                         loud_exit a = "rethrow inner try";
                         printf("rethrow inner try\n");
                         throwResume (zen){};
+                        throwResume a_zen;
                 } catchResume (zen *) {
                         loud_exit a = "rethrowing catch clause";
 …
         try {
                 try {
                         throwResume (yin){};
+                        throwResume a_yin;
                 } catchResume (yin *) {
                         printf("caught yin, will throw yang\n");
                         throwResume (yang){};
+                        throwResume a_yang;
                 } catchResume (yang *) {
                         printf("caught exception from same try\n");
 …
                 try {
                         printf("throwing first exception\n");
                         throwResume (yin){};
+                        throwResume a_yin;
                 } catchResume (yin *) {
                         printf("caught first exception\n");
                         try {
                                 printf("throwing second exception\n");
                                 throwResume (yang){};
+                                throwResume a_yang;
                         } catchResume (yang *) {
                                 printf("caught second exception\n");
 …
         try {
                 try {
                         throwResume (zen){};
                         throwResume (zen){};
+                        throwResume a_zen;
+                        throwResume a_zen;
                 } catchResume (zen *) {
                         printf("inner catch\n");
+                }
                 throwResume (zen){};
+                throwResume a_zen;
         } catchResume (zen *) {
                 printf("outer catch\n");
 …
 // Do a throw and rethrow in a void function.
 void in_void(void) {
+    zen a_zen = {&zen_vt};
         try {
                 try {
                         printf("throw\n");
                         throwResume (zen){};
+                        throwResume a_zen;
                 } catchResume (zen *) {
                         printf("rethrow\n");

tests/exceptions/terminate.cfa

-              rfeacef9
+              r5407cdc
 #include "except-io.hfa"
+TRIVIAL_EXCEPTION(yin);
+TRIVIAL_EXCEPTION(yang);
+TRIVIAL_EXCEPTION(zen);
+TRIVIAL_EXCEPTION(moment_of, zen);
+EHM_EXCEPTION(yin)();
+EHM_EXCEPTION(yang)();
+EHM_EXCEPTION(zen)();
+EHM_VIRTUAL_TABLE(yin, yin_vt);
+EHM_VIRTUAL_TABLE(yang, yang_vt);
+EHM_VIRTUAL_TABLE(zen, zen_vt);
 void in_void(void);
 int main(int argc, char * argv[]) {
+        yin a_yin = {&yin_vt};
+        yang a_yang = {&yang_vt};
+        zen a_zen = {&zen_vt};
         // The simple throw catch test.
         try {
                 loud_exit a = "simple try clause";
                 printf("simple throw\n");
                 throw (zen){};
+                throw a_zen;
                 printf("end of try clause\n");
         } catch (zen * error) {
 …
         // Throw catch-all test.
         try {
                 throw (zen){};
+                throw a_zen;
         } catch (exception_t * error) {
                 printf("catch-all\n");
+        }
-        printf("\n");
-        // Catch a parent of the given exception.
-        try {
-                printf("throwing child exception\n");
-                throw (moment_of){};
-        } catch (zen *) {
-                printf("inner parent match\n");
-        } catch (moment_of *) {
-                printf("outer exact match\n");
+        }
         printf("\n");
 …
         try {
                 try {
                         throw (yin){};
+                        throw a_yin;
                 } catch (zen *) {
                         printf("caught yin as zen\n");
 …
                         loud_exit a = "rethrow inner try";
                         printf("rethrow inner try\n");
                         throw (zen){};
+                        throw a_zen;
                 } catch (zen *) {
                         loud_exit a = "rethrowing catch clause";
 …
         try {
                 try {
                         throw (yin){};
+                        throw a_yin;
                 } catch (yin *) {
                         printf("caught yin, will throw yang\n");
                         throw (yang){};
+                        throw a_yang;
                 } catch (yang *) {
                         printf("caught exception from same try\n");
 …
                 try {
                         printf("throwing first exception\n");
                         throw (yin){};
+                        throw a_yin;
                 } catch (yin *) {
                         printf("caught first exception\n");
                         try {
                                 printf("throwing second exception\n");
                                 throw (yang){};
+                                throw a_yang;
                         } catch (yang *) {
                                 printf("caught second exception\n");
 …
         try {
                 try {
                         throw (zen){};
                         throw (zen){};
+                        throw a_zen;
+                        throw a_zen;
                 } catch (zen *) {
                         printf("inner catch\n");
+                }
                 throw (zen){};
+                throw a_zen;
         } catch (zen *) {
                 printf("outer catch\n");
 …
 // Do a throw and rethrow in a void function.
 void in_void(void) {
+        zen a_zen = {&zen_vt};
         try {
                 try {
                         printf("throw\n");
                         throw (zen){};
+                        throw a_zen;
                 } catch (zen *) {
                         printf("rethrow\n");

tests/exceptions/trash.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
+TRIVIAL_EXCEPTION(yin);
+TRIVIAL_EXCEPTION(yang);
+EHM_EXCEPTION(yin)();
+EHM_EXCEPTION(yang)();
+EHM_VIRTUAL_TABLE(yin, yin_vt);
+EHM_VIRTUAL_TABLE(yang, yang_vt);
 int main(int argc, char * argv[]) {
         try {
                 try {
                         throw (yin){};
+                        throw (yin){&yin_vt};
                 } finally {
                         try {
                                 throw (yang){};
+                                throw (yang){&yang_vt};
                         } catch (yin *) {
                                 printf("inner yin\n");

tests/exceptions/type-check.cfa

rfeacef9	r5407cdc
3	3	#include <exception.hfa>
4	4
5		~~TRIVIAL_EXCEPTION(truth~~);
	5	EHM_EXCEPTION(truth)();
6	6
7	7	int main(int argc, char * argv[]) {

tests/exceptions/virtual-cast.cfa

-              rfeacef9
+              r5407cdc
 #include <assert.h>
+// Hand defined alpha virtual type:
+struct __cfatid_struct_alpha {
+        __cfa__parent_vtable const * parent;
+};
+__attribute__(( section(".gnu.linkonce.__cfatid_alpha") ))
+struct __cfatid_struct_alpha __cfatid_alpha = {
+        (__cfa__parent_vtable *)0,
+};
 struct alpha_vtable {
         alpha_vtable const * const parent;
+        struct __cfatid_struct_alpha const * const __cfavir_typeid;
         char (*code)(void);
 };
 …
+// Hand defined beta virtual type:
+struct __cfatid_struct_beta {
+        __cfatid_struct_alpha const * parent;
+};
+__attribute__(( section(".gnu.linkonce.__cfatid_beta") ))
+struct __cfatid_struct_beta __cfatid_beta = {
+        &__cfatid_alpha,
+};
 struct beta_vtable {
         alpha_vtable const * const parent;
+        struct __cfatid_struct_beta const * const __cfavir_typeid;
         char (*code)(void);
 };
 …
+// Hand defined gamma virtual type:
+struct __cfatid_struct_gamma {
+        __cfatid_struct_beta const * parent;
+};
+__attribute__(( section(".gnu.linkonce.__cfatid_gamma") ))
+struct __cfatid_struct_gamma __cfatid_gamma = {
+        &__cfatid_beta,
+};
 struct gamma_vtable {
         beta_vtable const * const parent;
+        struct __cfatid_struct_gamma const * const __cfavir_typeid;
         char (*code)(void);
 };
 …
 extern "C" {
         alpha_vtable _alpha_vtable_instance = { 0, ret_a };
         beta_vtable _beta_vtable_instance = { &_alpha_vtable_instance, ret_b };
         gamma_vtable _gamma_vtable_instance = { &_beta_vtable_instance, ret_g };
+        alpha_vtable _alpha_vtable_instance = { &__cfatid_alpha, ret_a };
+        beta_vtable _beta_vtable_instance = { &__cfatid_beta, ret_b };
+        gamma_vtable _gamma_vtable_instance = { &__cfatid_gamma, ret_g };
+}

tests/exceptions/virtual-poly.cfa

-              rfeacef9
+              r5407cdc
 #include <assert.h>
+struct __cfatid_struct_mono_base {
+    __cfa__parent_vtable const * parent;
+};
+__attribute__(( section(".gnu.linkonce.__cfatid_mono_base") ))
+struct __cfatid_struct_mono_base __cfatid_mono_base = {
+    (__cfa__parent_vtable *)0,
+};
 struct mono_base_vtable {
         mono_base_vtable const * const parent;
+        __cfatid_struct_mono_base const * const __cfavir_typeid;
 };
 …
 forall(T)
+struct __cfatid_struct_mono_child {
+    __cfatid_struct_mono_base const * parent;
+};
+forall(T)
 struct mono_child_vtable {
         mono_base_vtable const * const parent;
+        __cfatid_struct_mono_child(T) const * const __cfavir_typeid;
 };
 …
 };
+mono_base_vtable _mono_base_vtable_instance @= { 0 };
+__cfatid_struct_mono_child(int) __cfatid_mono_child @= {
+        &__cfatid_mono_base,
+};
 mono_child_vtable(int) _mono_child_vtable_instance @= {
         &_mono_base_vtable_instance
+        &__cfatid_mono_child,
 };
 …
+}
+forall(U)
+struct __cfatid_struct_poly_base {
+    __cfa__parent_vtable const * parent;
+};
 forall(U)
 struct poly_base_vtable {
         poly_base_vtable(U) const * const parent;
+        __cfatid_struct_poly_base(U) const * const __cfavir_typeid;
 };
 …
 forall(V)
+struct __cfatid_struct_poly_child {
+    __cfatid_struct_poly_base(V) const * parent;
+};
+forall(V)
 struct poly_child_vtable {
         poly_base_vtable(V) const * const parent;
+        __cfatid_struct_poly_child(V) const * const __cfavir_typeid;
 };
 …
 };
+poly_base_vtable(int) _poly_base_vtable_instance @= { 0 };
+__cfatid_struct_poly_base(int) __cfatid_poly_base @= {
+        (__cfa__parent_vtable *)0,
+};
+__cfatid_struct_poly_child(int) __cfatid_poly_child = {
+    &__cfatid_poly_base,
+};
 poly_child_vtable(int) _poly_child_vtable_instance @= {
         &_poly_base_vtable_instance
+        &__cfatid_poly_child,
 };
-/* Resolver bug keeps me from adding these.
-poly_base_vtable(char) _poly_base_vtable_instance @= { 0 };
-poly_child_vtable(char) _poly_child_vtable_instance @= {
-        &_poly_base_vtable_instance
-};
-*/
 void poly_poly_test() {
 …
         mono_poly_test();
         poly_poly_test();
         printf( "done\n" );                             // non-empty .expect file
+        printf( "done\n" );
+}

tests/linking/exception-nothreads.cfa

-              rfeacef9
+              r5407cdc
 #include <exception.hfa>
+TRIVIAL_EXCEPTION(ping);
+EHM_EXCEPTION(ping)();
+EHM_VIRTUAL_TABLE(ping, ping_vt);
 int main(void) {
         try {
                 throwResume (ping){};
+                throwResume (ping){&ping_vt};
         } catchResume (ping *) {
                 printf("%s threads\n", threading_enabled() ? "with" : "no");

tests/linking/exception-withthreads.cfa

-              rfeacef9
+              r5407cdc
 #include "../exceptions/with-threads.hfa"
+TRIVIAL_EXCEPTION(ping);
+EHM_EXCEPTION(ping)();
+EHM_VIRTUAL_TABLE(ping, ping_vt);
 int main(void) {
         try {
                 throwResume (ping){};
+                throwResume (ping){&ping_vt};
         } catchResume (ping *) {
                 printf("%s threads\n", threading_enabled() ? "with" : "no");

tests/linking/weakso_nothd.cfa

rfeacef9	r5407cdc
6	6	//
7	7	// weakso_nothd.cfa --
8		// test whether or not usind a weakso locks pulls in threads
	8	// test whether or not using a weakso locks pulls in threads
9	9	//
10	10	// Author : Thierry Delisle

tests/meta/.expect/archVast.nast.arm64.txt

-              rfeacef9
+              r5407cdc
   char Alternatives are:
 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
       Variable Expression: FA64: signed int
+      Variable Expression: FA64: double
       ... with resolved type:
         signed int
+        double
     ... to:
       char
 …
 Cost ( 1, 0, 0, 0, 0, 0, 0 ): Explicit Cast of:
       Variable Expression: FA64: double
+      Variable Expression: FA64: signed int
       ... with resolved type:
         double
+        signed int
     ... to:
       char

tests/time.cfa

-              rfeacef9
+              r5407cdc
 // Created On       : Tue Mar 27 17:24:56 2018
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Jun 18 18:14:49 2020
 // Update Count     : 37
+// Last Modified On : Fri Apr 16 14:59:53 2021
+// Update Count     : 38
 //
 …
         //       | "Newfoundland" | getTime( Newfoundland )
         //       | "local" | getTime()
         //       | "local nsec" | getTimeNsec()
+        //       | "local nsec" | timeHiRes()
         //       | "PST" | PST();                                                               // getTime short form
         // sout | nl;

tests/unified_locking/.expect/locks.txt

-              rfeacef9
+              r5407cdc
 Start Test 6: owner lock and condition variable 3 wait/notify all
 Done Test 6
 Start Test 7: multi acquisiton lock and condition variable multiple acquire and wait/notify
+Start Test 7: fast lock and condition variable single wait/notify
 Done Test 7
 Start Test 8: owner lock and condition variable multiple acquire and wait/notify
+Start Test 8: fast lock and condition variable 3 wait/notify all
 Done Test 8
 Start Test 9: no lock condition variable wait/notify
+Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify
 Done Test 9
 Start Test 10: locked condition variable wait/notify with front()
+Start Test 10: owner lock and condition variable multiple acquire and wait/notify
 Done Test 10
+Start Test 11: no lock condition variable wait/notify
+Done Test 11
+Start Test 12: locked condition variable wait/notify with front()
+Done Test 12

tests/unified_locking/locks.cfa

-              rfeacef9
+              r5407cdc
 condition_variable( owner_lock ) c_o;
+fast_lock f;
+condition_variable( fast_lock ) c_f;
 thread T_C_M_WS1 {};
 …
+                }
                 unlock(s);
+        }
+}
+thread T_C_F_WS1 {};
+void main( T_C_F_WS1 & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                lock(f);
+                if(empty(c_f) && i != num_times - 1) {
+                        wait(c_f,f);
+                }else{
+                        notify_one(c_f);
+                }
+                unlock(f);
+        }
+}
+thread T_C_F_WB1 {};
+void main( T_C_F_WB1 & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                lock(f);
+                if(counter(c_f) == 3 || i == num_times - 1) {
+                        notify_all(c_f);
+                }else{
+                        wait(c_f,f);
+                }
+                unlock(f);
+        }
+}
 …
         printf("Done Test 6\n");
+        printf("Start Test 7: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
+        printf("Start Test 7: fast lock and condition variable single wait/notify\n");
+        {
+                T_C_F_WS1 t1[2];
+        }
+        printf("Done Test 7\n");
+        printf("Start Test 8: fast lock and condition variable 3 wait/notify all\n");
+        {
+                T_C_F_WB1 t1[4];
+        }
+        printf("Done Test 8\n");
+        printf("Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
+        {
                 T_C_M_WS2 t1[2];
+        }
         printf("Done Test 7\n");
         printf("Start Test 8: owner lock and condition variable multiple acquire and wait/notify\n");
+        printf("Done Test 9\n");
+        printf("Start Test 10: owner lock and condition variable multiple acquire and wait/notify\n");
+        {
                 T_C_O_WS2 t1[2];
+        }
         printf("Done Test 8\n");
         printf("Start Test 9: no lock condition variable wait/notify\n");
+        printf("Done Test 10\n");
+        printf("Start Test 11: no lock condition variable wait/notify\n");
+        {
                 T_C_NLW t1;
                 T_C_NLS t2;
+        }
         printf("Done Test 9\n");
         printf("Start Test 10: locked condition variable wait/notify with front()\n");
+        printf("Done Test 11\n");
+        printf("Start Test 12: locked condition variable wait/notify with front()\n");
+        {
                 T_C_S_WNF t1[2];
+        }
         printf("Done Test 10\n");
+        printf("Done Test 12\n");
         // removed to limit test duration. Full test is in long run tests

tests/vector_math/.expect/vec4_float.txt

-              rfeacef9
+              r5407cdc
 zero-assign:<0.,0.,0.,0.>
 fill-ctor:<1.23,1.23,1.23,1.23>
 ?-?:<0.02,0.43,-0.999998,-1e-06.>
 ?-=?:<0.02,0.43,-0.999998,-1e-06.>
 -?:<-0.02,-0.43,0.999998,1e-06.>
+?-?:<0.02,0.43,-0.999998,-1e-06>
+?-=?:<0.02,0.43,-0.999998,-1e-06>
+-?:<-0.02,-0.43,0.999998,1e-06>
 ?+?:<2.3,2.45,-9.2,-12.5>
 ?+=?:<2.3,2.45,-9.2,-12.5>

tools/gdb/utils-gdb.py

-              rfeacef9
+              r5407cdc
 gdb.execute('handle SIGUSR1 nostop noprint pass')
 CfaTypes = collections.namedtuple('CfaTypes', 'cluster_ptr processor_ptr thread_ptr int_ptr thread_state')
+CfaTypes = collections.namedtuple('CfaTypes', 'cluster_ptr processor_ptr thread_ptr int_ptr thread_state yield_state')
 class ThreadInfo:
 …
         # GDB types for various structures/types in CFA
         return CfaTypes(cluster_ptr = gdb.lookup_type('struct cluster').pointer(),
+                                  processor_ptr = gdb.lookup_type('struct processor').pointer(),
+                                         thread_ptr = gdb.lookup_type('struct $thread').pointer(),
+                                                int_ptr = gdb.lookup_type('int').pointer(),
+                                   thread_state = gdb.lookup_type('enum __Coroutine_State'))
+                processor_ptr = gdb.lookup_type('struct processor').pointer(),
+                thread_ptr = gdb.lookup_type('struct $thread').pointer(),
+                int_ptr = gdb.lookup_type('int').pointer(),
+                thread_state = gdb.lookup_type('enum __Coroutine_State'),
+                yield_state = gdb.lookup_type('enum __Preemption_Reason'))
 def get_addr(addr):
 …
         def print_thread(self, thread, tid, marked):
                 cfa_t = get_cfa_types()
+                self.print_formatted(marked, tid, thread['self_cor']['name'].string(), str(thread['state'].cast(cfa_t.thread_state)), str(thread))
+                ys = str(thread['preempted'].cast(cfa_t.yield_state))
+                if ys == '_X15__NO_PREEMPTIONKM19__Preemption_Reason_1':
+                        state = str(thread['state'].cast(cfa_t.thread_state))
+                elif ys == '_X18__ALARM_PREEMPTIONKM19__Preemption_Reason_1':
+                        state = 'preempted'
+                elif ys == '_X19__MANUAL_PREEMPTIONKM19__Preemption_Reason_1':
+                        state = 'yield'
+                elif ys == '_X17__POLL_PREEMPTIONKM19__Preemption_Reason_1':
+                        state = 'poll'
+                else:
+                        print("error: thread {} in undefined preemption state {}".format(thread, ys))
+                        state = 'error'
+                self.print_formatted(marked, tid, thread['self_cor']['name'].string(), state, str(thread))
         def print_threads_by_cluster(self, cluster, print_system = False):
 …
                 context = thread['context']
+                # must be at frame 0 to set pc register
+                gdb.execute('select-frame 0')
+                if gdb.selected_frame().architecture().name() != 'i386:x86-64':
+                        print('gdb debugging only supported for i386:x86-64 for now')
+                        return
+                # gdb seems to handle things much better if we pretend we just entered the context switch
+                # pretend the pc is __cfactx_switch and adjust the sp, base pointer doesn't need to change
                 # lookup for sp,fp and uSwitch
                 xsp = context['SP'] + 48
+                xsp = context['SP'] + 40 # 40 = 5 64bit registers : %r15, %r14, %r13, %r12, %rbx WARNING: x64 specific
                 xfp = context['FP']
                 # convert string so we can strip out the address
                 try:
                         xpc = get_addr(gdb.parse_and_eval('__cfactx_switch').address + 28)
+                        xpc = get_addr(gdb.parse_and_eval('__cfactx_switch').address)
                 except:
                         print("here")
                         return
-                # must be at frame 0 to set pc register
-                gdb.execute('select-frame 0')
                 # push sp, fp, pc into a global stack
 …
                 # update registers for new task
+                print('switching to ')
+                # print('switching to {} ({}) : [{}, {}, {}]'.format(thread['self_cor']['name'].string(), str(thread), str(xsp), str(xfp), str(xpc)))
+                print('switching to thread {} ({})'.format(str(thread), thread['self_cor']['name'].string()))
                 gdb.execute('set $rsp={}'.format(xsp))
                 gdb.execute('set $rbp={}'.format(xfp))
 …
                 argv = parse(arg)
-                print(argv)
                 if argv[0].isdigit():
                         cname = " ".join(argv[1:]) if len(argv) > 1 else None

Context Navigation

Changes in / [feacef9:5407cdc]

Legend: