Changeset 7770cc8

benchmark/Makefile.am

r94647b0	r7770cc8
613	613
614	614	RDQBENCHES = \
	615	rdq-churn-cfa \
615	616	rdq-cycle-cfa \
616	617	rdq-cycle-tokio \

benchmark/io/http/filecache.cfa

r94647b0	r7770cc8
185	185	sout \| "Filled cache from path \"" \| path \| "\" with" \| fcount \| "files";
186	186	if( conflicts > 0 ) {
187		sout \| "Found" \| conflicts \| "conflicts (seed: " \| options.file_cache.hash_seed \| ")";
	187	sout \| "Found" \| conflicts \| "conflicts (size: " \| file_cache.size \| ", seed: " \| options.file_cache.hash_seed \| ")";
188	188	#if defined(REJECT_CONFLICTS)
189	189	abort("Conflicts found in the cache");

benchmark/io/http/http_ring.cpp

-                      r94647b0
+                      r7770cc8
 // Get a fix reply based on the return code
 const char * http_msgs[] = {
         "HTTP/1.1 200 OK\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 15\r\nConnection: keep-alive\r\n\r\nHello, World!\r\n",
         "HTTP/1.1 400 Bad Request\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 404 Not Found\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 405 Method Not \r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 408 Request Timeout\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 413 Payload Too Large\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
         "HTTP/1.1 414 URI Too Long\r\nServer: HttoForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 200 OK\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 15\r\nConnection: keep-alive\r\n\r\nHello, World!\r\n",
+        "HTTP/1.1 400 Bad Request\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 404 Not Found\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 405 Method Not \r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 408 Request Timeout\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 413 Payload Too Large\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
+        "HTTP/1.1 414 URI Too Long\r\nServer: HttpForall\r\nContent-Type: text/plain\r\nContent-Length: 0 \r\n\r\n",
 };
 static_assert( KNOWN_CODES == (sizeof(http_msgs) / sizeof(http_msgs[0])) );

benchmark/io/http/main.cfa

-                      r94647b0
+                      r7770cc8
                         if(errno == EADDRINUSE) {
                                 if(waited == 0) {
+                                        if(!options.interactive) abort | "Port already in use in non-interactive mode. Aborting";
                                         sout | "Waiting for port";
                                 } else {
 …
                         init_protocol();
+                        {
                                 Worker workers[options.clopts.nworkers];
+                                Worker * workers = anew(options.clopts.nworkers);
                                 for(i; options.clopts.nworkers) {
                                         // if( options.file_cache.fixed_fds ) {
 …
+                                }
                                 sout | nl;
+                                if(!options.interactive) park();
+                                {
                                         char buffer[128];
 …
                                 sout | "Stopping connection threads..." | nonl; flush( sout );
+                                adelete(workers);
+                        }
                         sout | "done";

benchmark/io/http/options.cfa

-                      r94647b0
+                      r7770cc8
         false, // log
         false, // stats
+        true, // interactive
+, // redirect
+, // redirect
         { // file_cache
 …
         // bool sqkpoll = false;
         // bool iokpoll = false;
         unsigned nentries = 16;
+        unsigned nentries = 0;
         bool isolate = false;
 …
                 {'\0', "isolate",        "Create one cluster per processor", isolate, parse_settrue},
                 {'\0', "log",            "Enable logs", options.log, parse_settrue},
+                {'\0', "sout",           "Redirect standard out to file", options.reopen_stdout},
+                {'\0', "serr",           "Redirect standard error to file", options.reopen_stderr},
                 {'\0', "stats",          "Enable statistics", options.stats, parse_settrue},
+                {'\0', "shell",          "Disable interactive mode", options.interactive, parse_setfalse},
                 {'\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},
 …
         parse_args( argc, argv, opt, opt_cnt, "[OPTIONS]... [PATH]\ncforall http server", left );
         if( !is_pow2(nentries) ) {
+        if( nentries != 0 && !is_pow2(nentries) ) {
                 unsigned v = nentries;
                 v--;
 …
         options.file_cache.path = path;
+        if( options.reopen_stdout && options.reopen_stderr && 0 == strcmp(options.reopen_stdout, options.reopen_stderr) ) {
+                serr | "Redirect sout and serr to the same file is not supported";
+                exit(EXIT_FAILURE);
+        }
+        if( options.reopen_stdout ) {
+                sout | "redirecting sout to '" | options.reopen_stdout | "'";
+                FILE  * ret = freopen( options.reopen_stdout, "w", stdout);
+                if( ret == 0p ) {
+                        serr | "Failed to redirect sout to '" | options.reopen_stdout | "'";
+                        exit(EXIT_FAILURE);
+                }
+        }
+        if( options.reopen_stderr ) {
+                sout | "redirecting serr to '" | options.reopen_stderr | "'";
+                FILE  * ret = freopen( options.reopen_stderr, "w", stderr);
+                if( ret == 0p ) {
+                        serr | "Failed to redirect serr to '" | options.reopen_stderr | "'";
+                        exit(EXIT_FAILURE);
+                }
+        }
+}

benchmark/io/http/options.hfa

-                      r94647b0
+                      r7770cc8
         bool log;
         bool stats;
+        bool interactive;
+        const char * reopen_stdout;
+        const char * reopen_stderr;
         struct {

benchmark/io/http/protocol.cfa

-                      r94647b0
+                      r7770cc8
 #include <fstream.hfa>
 #include <iofwd.hfa>
+#include <io/types.hfa>
+#include <mutex_stmt.hfa>
 #include <assert.h>
 …
 #define PLAINTEXT_MEMCPY
 #define PLAINTEXT_NOCOPY
+#define LINKED_IO
 struct https_msg_str {
 …
+}
 static inline int answer( int fd, const char * it, int len) {
+static inline int answer( int fd, const char * it, int len ) {
         while(len > 0) {
                 // Call write
                 int ret = cfa_send(fd, it, len, 0, CFA_IO_LAZY);
                 if( ret < 0 ) {
                         if( errno == ECONNRESET || errno == EPIPE ) return -ECONNRESET;
+                        if( errno == ECONNRESET || errno == EPIPE ) { close(fd); return -ECONNRESET; }
                         if( errno == EAGAIN || errno == EWOULDBLOCK) return -EAGAIN;
 …
+}
+int answer_header( int fd, size_t size ) {
+        char buffer[512];
+        char * it = buffer;
+static int fill_header(char * it, size_t size) {
         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 len;
+}
+static int answer_header( int fd, size_t size ) {
+        char buffer[512];
+        int len = fill_header(buffer, size);
         return answer( fd, buffer, len );
+}
 …
+}
+[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;
+        int rlen = 0;
+        READ:
+        for() {
+                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];
+                if(ret < 0 ) {
+                        if( errno == EAGAIN || errno == EWOULDBLOCK) continue READ;
+                        if( errno == ECONNRESET ) return [E408, true, 0, 0];
+                        if( errno == EPIPE ) return [E408, true, 0, 0];
+                        abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                it[ret + 1] = '\0';
+                rlen += ret;
+                if( strstr( it, "\r\n\r\n" ) ) break;
+                it += ret;
+                count -= ret;
+                if( count < 1 ) return [E414, false, 0, 0];
+        }
+        if( options.log ) {
+                write(sout, buffer, rlen);
+                sout | nl;
+        }
+        it = buffer;
+        int ret = memcmp(it, "GET /", 5);
+        if( ret != 0 ) return [E400, false, 0, 0];
+        it += 5;
+        char * end = strstr( it, " " );
+        return [OK200, false, it, end - it];
+}
+int sendfile( int pipe[2], int fd, int ans_fd, size_t count ) {
+static int sendfile( int pipe[2], int fd, int ans_fd, size_t count ) {
         unsigned sflags = SPLICE_F_MOVE; // | SPLICE_F_MORE;
         off_t offset = 0;
 …
+}
+static void zero_sqe(struct io_uring_sqe * sqe) {
+        sqe->flags = 0;
+        sqe->ioprio = 0;
+        sqe->fd = 0;
+        sqe->off = 0;
+        sqe->addr = 0;
+        sqe->len = 0;
+        sqe->fsync_flags = 0;
+        sqe->__pad2[0] = 0;
+        sqe->__pad2[1] = 0;
+        sqe->__pad2[2] = 0;
+        sqe->fd = 0;
+        sqe->off = 0;
+        sqe->addr = 0;
+        sqe->len = 0;
+}
+enum FSM_STATE {
+        Initial,
+        Retry,
+        Error,
+        Done,
+};
+struct FSM_Result {
+        FSM_STATE state;
+        int error;
+};
+static inline void ?{}(FSM_Result & this) { this.state = Initial; this.error = 0; }
+static inline bool is_error(FSM_Result & this) { return Error == this.state; }
+static inline bool is_done(FSM_Result & this) { return Done == this.state; }
+static inline int error(FSM_Result & this, int error) {
+        this.error = error;
+        this.state = Error;
+        return error;
+}
+static inline int done(FSM_Result & this) {
+        this.state = Done;
+        return 0;
+}
+static inline int retry(FSM_Result & this) {
+        this.state = Retry;
+        return 0;
+}
+static inline int need(FSM_Result & this) {
+        switch(this.state) {
+                case Initial:
+                case Retry:
+                        return 1;
+                case Error:
+                        if(this.error == 0) mutex(serr) serr | "State marked error but code is 0";
+                case Done:
+                        return 0;
+        }
+}
+// Generator that handles sending the header
+generator header_g {
+        io_future_t f;
+        const char * next;
+        int fd; size_t len;
+        FSM_Result res;
+};
+static inline void ?{}(header_g & this, int fd, const char * it, size_t len ) {
+        this.next = it;
+        this.fd = fd;
+        this.len = len;
+}
+static inline void fill(header_g & this, struct io_uring_sqe * sqe) {
+        zero_sqe(sqe);
+        sqe->opcode = IORING_OP_SEND;
+        sqe->user_data = (uintptr_t)&this.f;
+        sqe->flags = IOSQE_IO_LINK;
+        sqe->fd = this.fd;
+        sqe->addr = (uintptr_t)this.next;
+        sqe->len = this.len;
+}
+static inline int error(header_g & this, int error) {
+        int ret = close(this.fd);
+        if( ret != 0 ) {
+                mutex(serr) serr | "Failed to close fd" | errno;
+        }
+        return error(this.res, error);
+}
+static inline int wait_and_process(header_g & this) {
+        wait(this.f);
+        // Did something crazy happen?
+        if(this.f.result > this.len) {
+                mutex(serr) serr | "HEADER sent too much!";
+                return error(this, -ERANGE);
+        }
+        // Something failed?
+        if(this.f.result < 0) {
+                int error = -this.f.result;
+                if( error == ECONNRESET ) return error(this, -ECONNRESET);
+                if( error == EPIPE ) return error(this, -EPIPE);
+                if( error == ECANCELED ) {
+                        mutex(serr) serr | "HEADER was cancelled, WTF!";
+                        return error(this, -ECONNRESET);
+                }
+                if( error == EAGAIN || error == EWOULDBLOCK) {
+                        mutex(serr) serr | "HEADER got eagain, WTF!";
+                        return error(this, -ECONNRESET);
+                }
+        }
+        // Done?
+        if(this.f.result == this.len) {
+                return done(this.res);
+        }
+        // It must be a Short read
+        this.len  -= this.f.result;
+        this.next += this.f.result;
+        reset(this.f);
+        return retry(this.res);
+}
+// Generator that handles splicing in a file
+struct splice_in_t {
+        io_future_t f;
+        int fd; int pipe; size_t len; off_t off;
+        FSM_Result res;
+};
+static inline void ?{}(splice_in_t & this, int fd, int pipe, size_t len) {
+        this.fd = fd;
+        this.pipe = pipe;
+        this.len = len;
+        this.off = 0;
+}
+static inline void fill(splice_in_t & this, struct io_uring_sqe * sqe) {
+        zero_sqe(sqe);
+        sqe->opcode = IORING_OP_SPLICE;
+        sqe->user_data = (uintptr_t)&this.f;
+        sqe->flags = 0;
+        sqe->splice_fd_in = this.fd;
+        sqe->splice_off_in = this.off;
+        sqe->fd = this.pipe;
+        sqe->off = (__u64)-1;
+        sqe->len = this.len;
+        sqe->splice_flags = SPLICE_F_MOVE;
+}
+static inline int wait_and_process(splice_in_t & this) {
+        wait(this.f);
+        // Something failed?
+        if(this.f.result < 0) {
+                int error = -this.f.result;
+                if( error == ECONNRESET ) return error(this.res, -ECONNRESET);
+                if( error == EPIPE ) return error(this.res, -EPIPE);
+                if( error == ECANCELED ) {
+                        mutex(serr) serr | "SPLICE IN was cancelled, WTF!";
+                        return error(this.res, -ECONNRESET);
+                }
+                if( error == EAGAIN || error == EWOULDBLOCK) {
+                        mutex(serr) serr | "SPLICE IN got eagain, WTF!";
+                        return error(this.res, -ECONNRESET);
+                }
+        }
+        // Did something crazy happen?
+        if(this.f.result > this.len) {
+                mutex(serr) serr | "SPLICE IN spliced too much!";
+                return error(this.res, -ERANGE);
+        }
+        // Done?
+        if(this.f.result == this.len) {
+                return done(this.res);
+        }
+        // It must be a Short read
+        this.len -= this.f.result;
+        this.off += this.f.result;
+        reset(this.f);
+        return retry(this.res);
+}
+generator splice_out_g {
+        io_future_t f;
+        int pipe; int fd; size_t len;
+        FSM_Result res;
+};
+static inline void ?{}(splice_out_g & this, int pipe, int fd, size_t len) {
+        this.pipe = pipe;
+        this.fd = fd;
+        this.len = len;
+}
+static inline void fill(splice_out_g & this, struct io_uring_sqe * sqe) {
+        zero_sqe(sqe);
+        sqe->opcode = IORING_OP_SPLICE;
+        sqe->user_data = (uintptr_t)&this.f;
+        sqe->flags = 0;
+        sqe->splice_fd_in = this.pipe;
+        sqe->splice_off_in = (__u64)-1;
+        sqe->fd = this.fd;
+        sqe->off = (__u64)-1;
+        sqe->len = this.len;
+        sqe->splice_flags = SPLICE_F_MOVE;
+}
+static inline int error(splice_out_g & this, int error) {
+        int ret = close(this.fd);
+        if( ret != 0 ) {
+                mutex(serr) serr | "Failed to close fd" | errno;
+        }
+        return error(this.res, error);
+}
+static inline void wait_and_process(splice_out_g & this) {
+        wait(this.f);
+        // Something failed?
+        if(this.f.result < 0) {
+                int error = -this.f.result;
+                if( error == ECONNRESET ) return error(this, -ECONNRESET);
+                if( error == EPIPE ) return error(this, -EPIPE);
+                if( error == ECANCELED ) {
+                        this.f.result = 0;
+                        goto SHORT_WRITE;
+                }
+                if( error == EAGAIN || error == EWOULDBLOCK) {
+                        mutex(serr) serr | "SPLICE OUT got eagain, WTF!";
+                        return error(this, -ECONNRESET);
+                }
+        }
+        // Did something crazy happen?
+        if(this.f.result > this.len) {
+                mutex(serr) serr | "SPLICE OUT spliced too much!" | this.f.result | ">" | this.len;
+                return error(this.res, -ERANGE);
+        }
+        // Done?
+        if(this.f.result == this.len) {
+                return done(this.res);
+        }
+SHORT_WRITE:
+        // It must be a Short Write
+        this.len -= this.f.result;
+        reset(this.f);
+        return retry(this.res);
+}
+int answer_sendfile( int pipe[2], int fd, int ans_fd, size_t fsize ) {
+        #if defined(LINKED_IO)
+                char buffer[512];
+                int len = fill_header(buffer, fsize);
+                header_g header = { fd, buffer, len };
+                splice_in_t splice_in = { ans_fd, pipe[1], fsize };
+                splice_out_g splice_out = { pipe[0], fd, fsize };
+                RETRY_LOOP: for() {
+                        int have = need(header.res) + need(splice_in.res) + 1;
+                        int idx = 0;
+                        struct io_uring_sqe * sqes[3];
+                        __u32 idxs[3];
+                        struct $io_context * ctx = cfa_io_allocate(sqes, idxs, have);
+                        if(need(splice_in.res)) { fill(splice_in, sqes[idx++]); }
+                        if(need(   header.res)) { fill(header   , sqes[idx++]); }
+                        fill(splice_out, sqes[idx]);
+                        // Submit everything
+                        asm volatile("": : :"memory");
+                        cfa_io_submit( ctx, idxs, have, false );
+                        // wait for the results
+                        // Always wait for splice-in to complete as
+                        // we may need to kill the connection if it fails
+                        // If it already completed, this is a no-op
+                        wait_and_process(splice_in);
+                        if(is_error(splice_in.res)) {
+                                mutex(serr) serr | "SPLICE IN failed with" | splice_in.res.error;
+                                close(fd);
+                        }
+                        // Process the other 2
+                        wait_and_process(header);
+                        wait_and_process(splice_out);
+                        if(is_done(splice_out.res)) {
+                                break RETRY_LOOP;
+                        }
+                        // We need to wait for the completion if
+                        // - both completed
+                        // - the header failed
+                        // -
+                        if(  is_error(header.res)
+                          || is_error(splice_in.res)
+                          || is_error(splice_out.res)) {
+                                return -ECONNRESET;
+                        }
+                }
+                return len + fsize;
+        #else
+                int ret = answer_header(fd, fsize);
+                if( ret < 0 ) { close(fd); return ret; }
+                return sendfile(pipe, fd, ans_fd, fsize);
+        #endif
+}
+[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;
+        int rlen = 0;
+        READ:
+        for() {
+                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];
+                if(ret < 0 ) {
+                        if( errno == EAGAIN || errno == EWOULDBLOCK) continue READ;
+                        if( errno == ECONNRESET ) { close(fd); return [E408, true, 0, 0]; }
+                        if( errno == EPIPE ) { close(fd); return [E408, true, 0, 0]; }
+                        abort( "read error: (%d) %s\n", (int)errno, strerror(errno) );
+                }
+                it[ret + 1] = '\0';
+                rlen += ret;
+                if( strstr( it, "\r\n\r\n" ) ) break;
+                it += ret;
+                count -= ret;
+                if( count < 1 ) return [E414, false, 0, 0];
+        }
+        if( options.log ) {
+                write(sout, buffer, rlen);
+                sout | nl;
+        }
+        it = buffer;
+        int ret = memcmp(it, "GET /", 5);
+        if( ret != 0 ) return [E400, false, 0, 0];
+        it += 5;
+        char * end = strstr( it, " " );
+        return [OK200, false, it, end - it];
+}
 //=============================================================================================
 …
 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",
+        "HTTP/1.1 200 OK\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: ",
+        "HTTP/1.1 200 OK\r\nServer: HttpForall\r\nConnection: keep-alive\r\nContent-Length: 15\r\nContent-Type: text/html\r\nDate: %s \r\n\r\nHello, World!\r\n",
+        "HTTP/1.1 400 Bad Request\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 404 Not Found\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 405 Method Not Allowed\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 408 Request Timeout\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 413 Payload Too Large\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
+        "HTTP/1.1 414 URI Too Long\nServer: HttpForall\nDate: %s \nContent-Type: text/plain\nContent-Length: 0 \n\n",
 };
 …
                 Time now = timeHiRes();
                 strftime( buff, 100, "%a, %d %b %Y %H:%M:%S %Z", now );
                 sout | "Updated date to '" | buff | "'";
+                // if( options.log ) sout | "Updated date to '" | buff | "'";
                 for(i; KNOWN_CODES) {
 …
                 this.idx = (this.idx + 1) % 2;
                 sout | "Date thread sleeping";
+                // if( options.log ) sout | "Date thread sleeping";
                 sleep(1`s);

benchmark/io/http/protocol.hfa

-                      r94647b0
+                      r7770cc8
 int answer_error( int fd, HttpCode code );
-int answer_header( int fd, size_t size );
 int answer_plaintext( int fd );
 int answer_empty( int fd );
+int answer_sendfile( int pipe[2], int fd, int ans_fd, size_t count );
 [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

-                      r94647b0
+                      r7770cc8
 void ?{}( Worker & this ) {
         size_t cli = rand() % options.clopts.cltr_cnt;
         ((thread&)this){ "Server Worker Thread", *options.clopts.instance[cli], 512000 };
+        ((thread&)this){ "Server Worker Thread", *options.clopts.instance[cli], 64000 };
         options.clopts.thrd_cnt[cli]++;
         this.pipe[0] = -1;
 …
+                        }
-                        // Send the header
-                        int ret = answer_header(fd, count);
-                        if( ret == -ECONNRESET ) break REQUEST;
                         // Send the desired file
                         ret = sendfile( this.pipe, fd, ans_fd, count);
+                        int ret = answer_sendfile( this.pipe, fd, ans_fd, count);
                         if( ret == -ECONNRESET ) break REQUEST;
 …
                 if( options.log ) sout | "=== Connection closed ===";
-                close(fd);
                 continue CONNECTION;
+        }

doc/theses/mubeen_zulfiqar_MMath/allocator.tex

-                      r94647b0
+                      r7770cc8
 \end{itemize}
 The new features added to uHeapLmmm (incl. @malloc_size@ routine)
+The new features added to uHeapLmmm (incl. @malloc\_size@ routine)
 \CFA alloc interface with examples.
 \begin{itemize}
 \item
 …
 We added a few more features and routines to the allocator's C interface that can make the allocator more usable to the programmers. THese features will programmer more control on the dynamic memory allocation.
 \subsubsection void * aalloc( size_t dim, size_t elemSize )
+\subsubsection void * aalloc( size\_t dim, size\_t elemSize )
 aalloc is an extension of malloc. It allows programmer to allocate a dynamic array of objects without calculating the total size of array explicitly. The only alternate of this routine in the other allocators is calloc but calloc also fills the dynamic memory with 0 which makes it slower for a programmer who only wants to dynamically allocate an array of objects without filling it with 0.
 \paragraph{Usage}
 aalloc takes two parameters.
 \begin{itemize}
 \item
 …
 It returns address of dynamic object allocatoed on heap that can contain dim number of objects of the size elemSize. On failure, it returns NULL pointer.
 \subsubsection void * resize( void * oaddr, size_t size )
+\subsubsection void * resize( void * oaddr, size\_t size )
 resize is an extension of relloc. It allows programmer to reuse a cuurently allocated dynamic object with a new size requirement. Its alternate in the other allocators is realloc but relloc also copy the data in old object to the new object which makes it slower for the programmer who only wants to reuse an old dynamic object for a new size requirement but does not want to preserve the data in the old object to the new object.
 \paragraph{Usage}
 resize takes two parameters.
 \begin{itemize}
 \item
 …
 It returns an object that is of the size given but it does not preserve the data in the old object. On failure, it returns NULL pointer.
 \subsubsection void * resize( void * oaddr, size_t nalign, size_t size )
+\subsubsection void * resize( void * oaddr, size\_t nalign, size\_t size )
 This resize is an extension of the above resize (FIX ME: cite above resize). In addition to resizing the size of of an old object, it can also realign the old object to a new alignment requirement.
 \paragraph{Usage}
 This resize takes three parameters. It takes an additional parameter of nalign as compared to the above resize (FIX ME: cite above resize).
 \begin{itemize}
 \item
 …
 It returns an object with the size and alignment given in the parameters. On failure, it returns a NULL pointer.
 \subsubsection void * amemalign( size_t alignment, size_t dim, size_t elemSize )
+\subsubsection void * amemalign( size\_t alignment, size\_t dim, size\_t elemSize )
 amemalign is a hybrid of memalign and aalloc. It allows programmer to allocate an aligned dynamic array of objects without calculating the total size of the array explicitly. It frees the programmer from calculating the total size of the array.
 \paragraph{Usage}
 amemalign takes three parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic array of objects that has the capacity to contain dim number of objects of the size of elemSize. The returned dynamic array is aligned to the given alignment. On failure, it returns NULL pointer.
 \subsubsection void * cmemalign( size_t alignment, size_t dim, size_t elemSize )
+\subsubsection void * cmemalign( size\_t alignment, size\_t dim, size\_t elemSize )
 cmemalign is a hybrid of amemalign and calloc. It allows programmer to allocate an aligned dynamic array of objects that is 0 filled. The current way to do this in other allocators is to allocate an aligned object with memalign and then fill it with 0 explicitly. This routine provides both features of aligning and 0 filling, implicitly.
 \paragraph{Usage}
 cmemalign takes three parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic array of objects that has the capacity to contain dim number of objects of the size of elemSize. The returned dynamic array is aligned to the given alignment and is 0 filled. On failure, it returns NULL pointer.
+\subsubsection size_t malloc_alignment( void * addr )
+malloc_alignment returns the alignment of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required alignment.
+\paragraph{Usage}
+malloc_alignment takes one parameters.
+\subsubsection size\_t malloc\_alignment( void * addr )
+malloc\_alignment returns the alignment of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required alignment.
+\paragraph{Usage}
+malloc\_alignment takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
+malloc_alignment returns the alignment of the given dynamic object. On failure, it return the value of default alignment of the uHeapLmmm allocator.
+\subsubsection bool malloc_zero_fill( void * addr )
+malloc_zero_fill returns whether a currently allocated dynamic object was initially zero filled at the time of allocation. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verifying the zero filled property of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was zero filled at the time of allocation.
+\paragraph{Usage}
+malloc_zero_fill takes one parameters.
+malloc\_alignment returns the alignment of the given dynamic object. On failure, it return the value of default alignment of the uHeapLmmm allocator.
+\subsubsection bool malloc\_zero\_fill( void * addr )
+malloc\_zero\_fill returns whether a currently allocated dynamic object was initially zero filled at the time of allocation. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verifying the zero filled property of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was zero filled at the time of allocation.
+\paragraph{Usage}
+malloc\_zero\_fill takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
+malloc_zero_fill returns true if the dynamic object was initially zero filled and return false otherwise. On failure, it returns false.
+\subsubsection size_t malloc_size( void * addr )
+malloc_size returns the allocation size of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required size. Its current alternate in the other allocators is malloc_usable_size. But, malloc_size is different from malloc_usable_size as malloc_usabe_size returns the total data capacity of dynamic object including the extra space at the end of the dynamic object. On the other hand, malloc_size returns the size that was given to the allocator at the allocation of the dynamic object. This size is updated when an object is realloced, resized, or passed through a similar allocator routine.
+\paragraph{Usage}
+malloc_size takes one parameters.
+malloc\_zero\_fill returns true if the dynamic object was initially zero filled and return false otherwise. On failure, it returns false.
+\subsubsection size\_t malloc\_size( void * addr )
+malloc\_size returns the allocation size of a currently allocated dynamic object. It allows the programmer in memory management and personal bookkeeping. It helps the programmer in verofying the alignment of a dynamic object especially in a scenerio similar to prudcer-consumer where a producer allocates a dynamic object and the consumer needs to assure that the dynamic object was allocated with the required size. Its current alternate in the other allocators is malloc\_usable\_size. But, malloc\_size is different from malloc\_usable\_size as malloc\_usabe\_size returns the total data capacity of dynamic object including the extra space at the end of the dynamic object. On the other hand, malloc\_size returns the size that was given to the allocator at the allocation of the dynamic object. This size is updated when an object is realloced, resized, or passed through a similar allocator routine.
+\paragraph{Usage}
+malloc\_size takes one parameters.
 \begin{itemize}
 \item
 addr: the address of the currently allocated dynamic object.
 \end{itemize}
 malloc_size returns the allocation size of the given dynamic object. On failure, it return zero.
 \subsubsection void * realloc( void * oaddr, size_t nalign, size_t size )
+malloc\_size returns the allocation size of the given dynamic object. On failure, it return zero.
+\subsubsection void * realloc( void * oaddr, size\_t nalign, size\_t size )
 This realloc is an extension of the default realloc (FIX ME: cite default realloc). In addition to reallocating an old object and preserving the data in old object, it can also realign the old object to a new alignment requirement.
 \paragraph{Usage}
 This realloc takes three parameters. It takes an additional parameter of nalign as compared to the default realloc.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * aalloc( size_t dim )
+\subsubsection T * aalloc( size\_t dim )
 This aalloc is a simplified polymorphic form of above aalloc (FIX ME: cite aalloc). It takes one parameter as compared to the above aalloc that takes two parameters.
 \paragraph{Usage}
 aalloc takes one parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * calloc( size_t dim )
+\subsubsection T * calloc( size\_t dim )
 This calloc is a simplified polymorphic form of defualt calloc (FIX ME: cite calloc). It takes one parameter as compared to the default calloc that takes two parameters.
 \paragraph{Usage}
 This calloc takes one parameter.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. On failure, it return NULL pointer.
 \subsubsection T * resize( T * ptr, size_t size )
+\subsubsection T * resize( T * ptr, size\_t size )
 This resize is a simplified polymorphic form of above resize (FIX ME: cite resize with alignment). It takes two parameters as compared to the above resize that takes three parameters. It frees the programmer from explicitly mentioning the alignment of the allocation as CFA provides gives allocator the liberty to get the alignment of the returned type.
 \paragraph{Usage}
 This resize takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size given in paramters. The returned object is aligned to the alignemtn of type T. On failure, it return NULL pointer.
 \subsubsection T * realloc( T * ptr, size_t size )
+\subsubsection T * realloc( T * ptr, size\_t size )
 This realloc is a simplified polymorphic form of defualt realloc (FIX ME: cite realloc with align). It takes two parameters as compared to the above realloc that takes three parameters. It frees the programmer from explicitly mentioning the alignment of the allocation as CFA provides gives allocator the liberty to get the alignment of the returned type.
 \paragraph{Usage}
 This realloc takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size given in paramters that preserves the data in the given object. The returned object is aligned to the alignemtn of type T. On failure, it return NULL pointer.
 \subsubsection T * memalign( size_t align )
+\subsubsection T * memalign( size\_t align )
 This memalign is a simplified polymorphic form of defualt memalign (FIX ME: cite memalign). It takes one parameters as compared to the default memalign that takes two parameters.
 \paragraph{Usage}
 memalign takes one parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T that is aligned to given parameter align. On failure, it return NULL pointer.
 \subsubsection T * amemalign( size_t align, size_t dim )
+\subsubsection T * amemalign( size\_t align, size\_t dim )
 This amemalign is a simplified polymorphic form of above amemalign (FIX ME: cite amemalign). It takes two parameter as compared to the above amemalign that takes three parameters.
 \paragraph{Usage}
 amemalign takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. The returned object is aligned to the given parameter align. On failure, it return NULL pointer.
 \subsubsection T * cmemalign( size_t align, size_t dim  )
+\subsubsection T * cmemalign( size\_t align, size\_t dim  )
 This cmemalign is a simplified polymorphic form of above cmemalign (FIX ME: cite cmemalign). It takes two parameter as compared to the above cmemalign that takes three parameters.
 \paragraph{Usage}
 cmemalign takes two parameters.
 \begin{itemize}
 \item
 …
 It returns a dynamic object that has the capacity to contain dim number of objects, each of the size of type T. The returned object is aligned to the given parameter align and is zero filled. On failure, it return NULL pointer.
+\subsubsection T * aligned_alloc( size_t align )
+This aligned_alloc is a simplified polymorphic form of defualt aligned_alloc (FIX ME: cite aligned_alloc). It takes one parameter as compared to the default aligned_alloc that takes two parameters.
+\paragraph{Usage}
+This aligned_alloc takes one parameter.
+\subsubsection T * aligned\_alloc( size\_t align )
+This aligned\_alloc is a simplified polymorphic form of defualt aligned\_alloc (FIX ME: cite aligned\_alloc). It takes one parameter as compared to the default aligned\_alloc that takes two parameters.
+\paragraph{Usage}
+This aligned\_alloc takes one parameter.
 \begin{itemize}
 \item
 …
 It returns a dynamic object of the size of type T that is aligned to the given parameter. On failure, it return NULL pointer.
+\subsubsection int posix_memalign( T ** ptr, size_t align )
+This posix_memalign is a simplified polymorphic form of defualt posix_memalign (FIX ME: cite posix_memalign). It takes two parameters as compared to the default posix_memalign that takes three parameters.
+\paragraph{Usage}
+This posix_memalign takes two parameter.
+\subsubsection int posix\_memalign( T ** ptr, size\_t align )
+This posix\_memalign is a simplified polymorphic form of defualt posix\_memalign (FIX ME: cite posix\_memalign). It takes two parameters as compared to the default posix\_memalign that takes three parameters.
+\paragraph{Usage}
+This posix\_memalign takes two parameter.
 \begin{itemize}
 \item
 …
 align: required alignment of the dynamic object.
 \end{itemize}
 It stores address of the dynamic object of the size of type T in given parameter ptr. This object is aligned to the given parameter. On failure, it return NULL pointer.
 …
 It returns a dynamic object of the size that is calcutaed by rouding the size of type T. The returned object is also aligned to the page size. On failure, it return NULL pointer.
 \subsection{Alloc Interface}
+\subsection Alloc Interface
 In addition to improve allocator interface both for CFA and our standalone allocator uHeapLmmm in C. We also added a new alloc interface in CFA that increases usability of dynamic memory allocation.
 This interface helps programmers in three major ways.
 \begin{itemize}
 \item
 …
 This is the only parameter in the alloc routine that has a fixed-position and it is also the only parameter that does not use a backtick function. It has to be passed at the first position to alloc call in-case of an array allocation of objects of type T.
 It represents the required number of members in the array allocation as in CFA's aalloc (FIX ME: cite aalloc).
 This parameter should be of type size_t.
+This parameter should be of type size\_t.
 Example: int a = alloc( 5 )
 …
 \paragraph{Align}
 This parameter is position-free and uses a backtick routine align (`align). The parameter passed with `align should be of type size_t. If the alignment parameter is not a power of two or is less than the default alignment of the allocator (that can be found out using routine libAlign in CFA) then the passed alignment parameter will be rejected and the default alignment will be used.
+This parameter is position-free and uses a backtick routine align (`align). The parameter passed with `align should be of type size\_t. If the alignment parameter is not a power of two or is less than the default alignment of the allocator (that can be found out using routine libAlign in CFA) then the passed alignment parameter will be rejected and the default alignment will be used.
 Example: int b = alloc( 5 , 64`align )
 …
 This parameter is position-free and uses a backtick routine fill (`fill). In case of realloc, only the extra space after copying the data in the old object will be filled with given parameter.
 Three types of parameters can be passed using `fill.
 \begin{itemize}
 \item

doc/theses/mubeen_zulfiqar_MMath/background.tex

-                      r94647b0
+                      r7770cc8
 ====================
+\cite{Wasik08}
+\section{Background}
+% FIXME: cite wasik
+\cite{wasik.thesis}
+\subsection{Memory Allocation}
+With dynamic allocation being an important feature of C, there are many standalone memory allocators that have been designed for different purposes. For this thesis, we chose 7 of the most popular and widely used memory allocators.
+\paragraph{dlmalloc}
+dlmalloc (FIX ME: cite allocator) is a thread-safe allocator that is single threaded and single heap. dlmalloc maintains free-lists of different sizes to store freed dynamic memory. (FIX ME: cite wasik)
+\paragraph{hoard}
+Hoard (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and using a heap layer framework. It has per-thred heaps that have thread-local free-lists, and a gloabl shared heap. (FIX ME: cite wasik)
+\paragraph{jemalloc}
+jemalloc (FIX ME: cite allocator) is a thread-safe allocator that uses multiple arenas. Each thread is assigned an arena. Each arena has chunks that contain contagious memory regions of same size. An arena has multiple chunks that contain regions of multiple sizes.
+\paragraph{ptmalloc}
+ptmalloc (FIX ME: cite allocator) is a modification of dlmalloc. It is a thread-safe multi-threaded memory allocator that uses multiple heaps. ptmalloc heap has similar design to dlmalloc's heap.
+\paragraph{rpmalloc}
+rpmalloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses per-thread heap. Each heap has multiple size-classes and each size-calss contains memory regions of the relevant size.
+\paragraph{tbb malloc}
+tbb malloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses private heap for each thread. Each private-heap has multiple bins of different sizes. Each bin contains free regions of the same size.
+\paragraph{tc malloc}
+tcmalloc (FIX ME: cite allocator) is a thread-safe allocator. It uses per-thread cache to store free objects that prevents contention on shared resources in multi-threaded application. A central free-list is used to refill per-thread cache when it gets empty.
+\subsection{Benchmarks}
+There are multiple benchmarks that are built individually and evaluate different aspects of a memory allocator. But, there is not standard set of benchamrks that can be used to evaluate multiple aspects of memory allocators.
+\paragraph{threadtest}
+(FIX ME: cite benchmark and hoard) Each thread repeatedly allocates and then deallocates 100,000 objects. Runtime of the benchmark evaluates its efficiency.
+\paragraph{shbench}
+(FIX ME: cite benchmark and hoard) Each thread allocates and randomly frees a number of random-sized objects. It is a stress test that also uses runtime to determine efficiency of the allocator.
+\paragraph{larson}
+(FIX ME: cite benchmark and hoard) Larson simulates a server environment. Multiple threads are created where each thread allocator and free a number of objects within a size range. Some objects are passed from threads to the child threads to free. It caluculates memory operations per second as an indicator of memory allocator's performance.

doc/theses/mubeen_zulfiqar_MMath/benchmarks.tex

r94647b0	r7770cc8
149	149	*** FIX ME: Insert a figure of above benchmark with description
150	150
151		\paragrpah{Relevant Knobs}
	151	\paragraph{Relevant Knobs}
152	152	*** FIX ME: Insert Relevant Knobs
153	153

doc/theses/mubeen_zulfiqar_MMath/intro.tex

-                      r94647b0
+                      r7770cc8
 \begin{itemize}
 \item
 aligned_alloc
+aligned\_alloc
 \item
 malloc_usable_size
+malloc\_usable\_size
 \item
 memalign
 \item
 posix_memalign
+posix\_memalign
 \item
 pvalloc
 …
 With the rise of concurrent applications, memory allocators should be able to fulfill dynamic memory requests from multiple threads in parallel without causing contention on shared resources. There needs to be a set of a standard benchmarks that can be used to evaluate an allocator's performance in different scenerios.
-\section{Background}
-\subsection{Memory Allocation}
-With dynamic allocation being an important feature of C, there are many standalone memory allocators that have been designed for different purposes. For this thesis, we chose 7 of the most popular and widely used memory allocators.
-\paragraph{dlmalloc}
-dlmalloc (FIX ME: cite allocator) is a thread-safe allocator that is single threaded and single heap. dlmalloc maintains free-lists of different sizes to store freed dynamic memory. (FIX ME: cite wasik)
-\paragraph{hoard}
-Hoard (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and using a heap layer framework. It has per-thred heaps that have thread-local free-lists, and a gloabl shared heap. (FIX ME: cite wasik)
-\paragraph{jemalloc}
-jemalloc (FIX ME: cite allocator) is a thread-safe allocator that uses multiple arenas. Each thread is assigned an arena. Each arena has chunks that contain contagious memory regions of same size. An arena has multiple chunks that contain regions of multiple sizes.
-\paragraph{ptmalloc}
-ptmalloc (FIX ME: cite allocator) is a modification of dlmalloc. It is a thread-safe multi-threaded memory allocator that uses multiple heaps. ptmalloc heap has similar design to dlmalloc's heap.
-\paragraph{rpmalloc}
-rpmalloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses per-thread heap. Each heap has multiple size-classes and each size-calss contains memory regions of the relevant size.
-\paragraph{tbb malloc}
-tbb malloc (FIX ME: cite allocator) is a thread-safe allocator that is multi-threaded and uses private heap for each thread. Each private-heap has multiple bins of different sizes. Each bin contains free regions of the same size.
-\paragraph{tc malloc}
-tcmalloc (FIX ME: cite allocator) is a thread-safe allocator. It uses per-thread cache to store free objects that prevents contention on shared resources in multi-threaded application. A central free-list is used to refill per-thread cache when it gets empty.
-\subsection{Benchmarks}
-There are multiple benchmarks that are built individually and evaluate different aspects of a memory allocator. But, there is not standard set of benchamrks that can be used to evaluate multiple aspects of memory allocators.
-\paragraph{threadtest}
-(FIX ME: cite benchmark and hoard) Each thread repeatedly allocates and then deallocates 100,000 objects. Runtime of the benchmark evaluates its efficiency.
-\paragraph{shbench}
-(FIX ME: cite benchmark and hoard) Each thread allocates and randomly frees a number of random-sized objects. It is a stress test that also uses runtime to determine efficiency of the allocator.
-\paragraph{larson}
-(FIX ME: cite benchmark and hoard) Larson simulates a server environment. Multiple threads are created where each thread allocator and free a number of objects within a size range. Some objects are passed from threads to the child threads to free. It caluculates memory operations per second as an indicator of memory allocator's performance.
 \section{Research Objectives}

doc/theses/mubeen_zulfiqar_MMath/performance.tex

-                      r94647b0
+                      r7770cc8
 tc               &             &  \\
 \end{tabularx}
+(FIX ME: complete table)
+%(FIX ME: complete table)
 \section{Experiment Environment}

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.bib

-                      r94647b0
+                      r7770cc8
         address =       "Reading, Massachusetts"
+}
+@article{wasik.thesis,
+    author        = "Ayelet Wasik",
+    title         = "Features of A Multi-Threaded Memory Alloator",
+    publisher     = "University of Waterloo",
+    year          = "2008"
+}

doc/theses/mubeen_zulfiqar_MMath/uw-ethesis.tex

-                      r94647b0
+                      r7770cc8
 \usepackage{graphicx}
 \usepackage{comment} % Removes large sections of the document.
+\usepackage{tabularx}
 % Hyperlinks make it very easy to navigate an electronic document.
 …
 % Tip: Putting each sentence on a new line is a way to simplify later editing.
 %----------------------------------------------------------------------
+\begin{sloppypar}
 \input{intro}
 \input{background}
 …
 \input{performance}
 \input{conclusion}
+\end{sloppypar}
 %----------------------------------------------------------------------

doc/theses/thierry_delisle_PhD/.gitignore

-                      r94647b0
+                      r7770cc8
 comp_II/presentation.pdf
+seminars/build/
+seminars/img/*.fig.bak
+seminars/*.pdf
 thesis/build/
 thesis/fig/*.fig.bak

doc/theses/thierry_delisle_PhD/thesis/Makefile

-                      r94647b0
+                      r7770cc8
         practice \
         io \
+        eval_micro \
+        eval_macro \
 }}
 …
         pivot_ring \
         system \
+        cycle \
+}

doc/theses/thierry_delisle_PhD/thesis/thesis.tex

-                      r94647b0
+                      r7770cc8
 %======================================================================
 % University of Waterloo Thesis Template for LaTeX
 % Last Updated November, 2020
 % by Stephen Carr, IST Client Services,
+% University of Waterloo Thesis Template for LaTeX
+% Last Updated November, 2020
+% by Stephen Carr, IST Client Services,
 % University of Waterloo, 200 University Ave. W., Waterloo, Ontario, Canada
 % FOR ASSISTANCE, please send mail to request@uwaterloo.ca
 …
 % Some important notes on using this template and making it your own...
 % The University of Waterloo has required electronic thesis submission since October 2006.
+% The University of Waterloo has required electronic thesis submission since October 2006.
 % See the uWaterloo thesis regulations at
 % https://uwaterloo.ca/graduate-studies/thesis.
 % This thesis template is geared towards generating a PDF version optimized for viewing on an electronic display, including hyperlinks within the PDF.
 % DON'T FORGET TO ADD YOUR OWN NAME AND TITLE in the "hyperref" package configuration below.
+% DON'T FORGET TO ADD YOUR OWN NAME AND TITLE in the "hyperref" package configuration below.
 % THIS INFORMATION GETS EMBEDDED IN THE PDF FINAL PDF DOCUMENT.
 % You can view the information if you view properties of the PDF document.
 % Many faculties/departments also require one or more printed copies.
 % This template attempts to satisfy both types of output.
+% Many faculties/departments also require one or more printed copies.
+% This template attempts to satisfy both types of output.
 % See additional notes below.
 % It is based on the standard "book" document class which provides all necessary sectioning structures and allows multi-part theses.
 …
 % For people who prefer to install their own LaTeX distributions on their own computers, and process the source files manually, the following notes provide the sequence of tasks:
 % E.g. to process a thesis called "mythesis.tex" based on this template, run:
 % pdflatex mythesis     -- first pass of the pdflatex processor
 % bibtex mythesis       -- generates bibliography from .bib data file(s)
 % makeindex         -- should be run only if an index is used
+% makeindex         -- should be run only if an index is used
 % pdflatex mythesis     -- fixes numbering in cross-references, bibliographic references, glossaries, index, etc.
 % pdflatex mythesis     -- it takes a couple of passes to completely process all cross-references
 % If you use the recommended LaTeX editor, Texmaker, you would open the mythesis.tex file, then click the PDFLaTeX button. Then run BibTeX (under the Tools menu).
 % Then click the PDFLaTeX button two more times.
+% Then click the PDFLaTeX button two more times.
 % If you have an index as well,you'll need to run MakeIndex from the Tools menu as well, before running pdflatex
 % the last two times.
 …
 % Tip: Photographs should be cropped and compressed so as not to be too large.
 % To create a PDF output that is optimized for double-sided printing:
+% To create a PDF output that is optimized for double-sided printing:
 % 1) comment-out the \documentclass statement in the preamble below, and un-comment the second \documentclass line.
 % 2) change the value assigned below to the boolean variable "PrintVersion" from " false" to "true".
 …
 % If you have to, it's easier to make changes to nomenclature once here than in a million places throughout your thesis!
 \newcommand{\package}[1]{\textbf{#1}} % package names in bold text
 \newcommand{\cmmd}[1]{\textbackslash\texttt{#1}} % command name in tt font
+\newcommand{\cmmd}[1]{\textbackslash\texttt{#1}} % command name in tt font
 \newcommand{\href}[1]{#1} % does nothing, but defines the command so the print-optimized version will ignore \href tags (redefined by hyperref pkg).
 %\newcommand{\texorpdfstring}[2]{#1} % does nothing, but defines the command
 …
 \part{Evaluation}
 \label{Evaluation}
 \chapter{Theoretical and Existance Proofs}
 \chapter{Micro-Benchmarks}
 \chapter{Larger-Scale applications}
+% \chapter{Theoretical and Existance Proofs}
+\input{text/eval_micro.tex}
+\input{text/eval_macro.tex}
 \part{Conclusion \& Annexes}

doc/user/user.tex

-                      r94647b0
+                      r7770cc8
 %% Created On       : Wed Apr  6 14:53:29 2016
 %% Last Modified By : Peter A. Buhr
 %% Last Modified On : Mon May 31 09:03:34 2021
 %% Update Count     : 5071
+%% Last Modified On : Sun Oct 10 12:45:00 2021
+%% Update Count     : 5095
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 …
 \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 ";
+The common usage is the short form of the mutex statement\index{ostream@©ostream©!mutex@©mutex©} to lock a stream during a single cascaded I/O expression, \eg:
+\begin{cfa}
+$\emph{thread\(_1\)}$ : ®mutex()® sout | "abc " | "def ";
+$\emph{thread\(_2\)}$ : ®mutex()® sout | "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.
 …
 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}$
+To lock a stream across multiple I/O operations, he long form of the mutex statement is used, \eg:
+\begin{cfa}
+®mutex( sout )® {
         sout | 1;
         sout | ®acquire® | 2 | 3;                               $\C{// unnecessary, but ok to acquire and release again}$
+        ®mutex() sout® | 2 | 3;                         $\C{// unnecessary, but ok because of recursive lock}$
         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.
+} // implicitly release sout lock
+\end{cfa}
+Note, the unnecessary ©mutex© in the middle of the mutex statement, 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}$
+®mutex( sin )® {
         int x, y, z, w;
         sin | x;
         sin | ®acquire® | y | z;                                $\C{// unnecessary, but ok to acquire and release again}$
+        ®mutex() sin® | y | z;                          $\C{// unnecessary, but ok because of recursive lock}$
         sin | w;
 }       // implicitly release the lock when "acq" is deallocated
+} // implicitly release sin lock
 \end{cfa}
 Again, the order of the reading threads is non-deterministic.
 …
 \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}$
+®mutex() sout® | "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.
 …
 \begin{cfa}
 int ®data® = rtn( mon );
 sout | acquire | "data:" | ®data®;
+mutex() sout | "data:" | ®data®;
 \end{cfa}
 …
 \section{String Stream}
+All the stream formatting capabilities are available to format text to/from a C string rather than to a stream file.
+\VRef[Figure]{f:StringStreamProcessing} shows writing (output) and reading (input) from a C string.
+The stream types ©ostrstream© and ©istrstream© provide all the stream formatting capabilities to/from a C string rather than a stream file.
+\VRef[Figure]{f:StringStreamProcessing} shows writing (output) to and reading (input) from a C string.
+The only string stream operations different from a file stream are:
+\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
+\item
+constructors to create a stream that writes to a write buffer (©ostrstream©) of ©size©, or reads from a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
+\begin{cfa}
+void ?{}( ostrstream &, char buf[], size_t size );
+void ?{}( istrstream & is, char buf[] );
+\end{cfa}
+\item
+\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
+\begin{cfa}
+ostrstream & write( ostrstream & os, FILE * stream = stdout );
+\end{cfa}
+There is no ©read© for ©istrstream©.
+\end{itemize}
 \begin{figure}
 \begin{cfa}
 …
         double x = 12345678.9, y = 98765.4321e-11;
         osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)); $\C{// same lines of output}$
         write( osstr );
         printf( "%s", buf );
         sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y));
         char buf2[] = "12 14 15 3.5 7e4"; $\C{// input buffer}$
+        osstr | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
+        write( osstr ); $\C{// write string to stdout}$
+        printf( "%s", buf ); $\C{// same lines of output}$
+        sout | i | hex(j) | wd(10, k) | sci(x) | unit(eng(y)) | "abc";
+        char buf2[] = "12 14 15 3.5 7e4 abc"; $\C{// input buffer}$
         ®istrstream isstr = { buf2 };®
+        isstr | i | j | k | x | y;
+        sout | i | j | k | x | y;
+}
+        char s[10];
+        isstr | i | j | k | x | y | s;
+        sout  | i | j | k | x | y | s;
+}
+0x5          7 1.234568e+07 987.654n abc
+0x5          7 1.234568e+07 987.654n abc
+0x5          7 1.234568e+07 987.654n abc
+14 15 3.5 70000. abc
 \end{cfa}
 \caption{String Stream Processing}
 \label{f:StringStreamProcessing}
 \end{figure}
-\VRef[Figure]{f:StringStreamFunctions} shows the string stream operations.
-\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
-\item
-\Indexc{write} (©ostrstream© only) writes all the buffered characters to the specified stream (©stdout© default).
-\end{itemize}
-The constructor functions:
-\begin{itemize}[topsep=4pt,itemsep=2pt,parsep=0pt]
-\item
-create a bound stream to a write buffer (©ostrstream©) of ©size© or a read buffer (©istrstream©) containing a C string terminated with ©'\0'©.
-\end{itemize}
-\begin{figure}
-\begin{cfa}
-// *********************************** ostrstream ***********************************
-ostrstream & write( ostrstream & os, FILE * stream = stdout );
-void ?{}( ostrstream &, char buf[], size_t size );
-// *********************************** istrstream ***********************************
-void ?{}( istrstream & is, char buf[] );
-\end{cfa}
-\caption{String Stream Functions}
-\label{f:StringStreamFunctions}
-\end{figure}
 \begin{comment}

libcfa/prelude/bootloader.cf

-                      r94647b0
+                      r7770cc8
 char ** cfa_args_argv;
 char ** cfa_args_envp;
 int cfa_main_returned = 0;
+__attribute__((weak)) extern int cfa_main_returned;
 int main(int argc, char* argv[], char* envp[]) {
 …
         cfa_args_envp = envp;
         int ret = invoke_main(argc, argv, envp);
         cfa_main_returned = 1;
+        if(&cfa_main_returned) cfa_main_returned = 1;
         return ret;
+}

libcfa/src/concurrency/io.cfa

-                      r94647b0
+                      r7770cc8
+        }
         void __cfa_io_flush( processor * proc ) {
+        bool __cfa_io_flush( processor * proc, bool wait ) {
                 /* paranoid */ verify( ! __preemption_enabled() );
                 /* paranoid */ verify( proc );
 …
                 $io_context & ctx = *proc->io.ctx;
-                // for(i; 2) {
-                //      unsigned idx = proc->rdq.id + i;
-                //      cltr->ready_queue.lanes.tscs[idx].tv = -1ull;
-                // }
                 __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);
+                int ret = syscall( __NR_io_uring_enter, ctx.fd, ctx.sq.to_submit, wait ? 1 : 0, 0, (sigset_t *)0p, _NSIG / 8);
                 if( ret < 0 ) {
                         switch((int)errno) {
 …
                                 // Update statistics
                                 __STATS__( false, io.calls.errors.busy ++; )
+                                // for(i; 2) {
+                                //      unsigned idx = proc->rdq.id + i;
+                                //      cltr->ready_queue.lanes.tscs[idx].tv = rdtscl();
+                                // }
+                                return;
+                                return false;
                         default:
                                 abort( "KERNEL ERROR: IO_URING SYSCALL - (%d) %s\n", (int)errno, strerror(errno) );
 …
                 ctx.proc->io.pending = false;
                 ready_schedule_lock();
                 __cfa_io_drain( proc );
+                bool ret = __cfa_io_drain( proc );
                 ready_schedule_unlock();
+                // for(i; 2) {
+                //      unsigned idx = proc->rdq.id + i;
+                //      cltr->ready_queue.lanes.tscs[idx].tv = rdtscl();
+                // }
+                return ret;
+        }
 …
+        }
         //=============================================================================================
         // submission
 …
                 // Make the sqes visible to the submitter
                 __atomic_store_n(sq.kring.tail, tail + have, __ATOMIC_RELEASE);
                 sq.to_submit++;
+                sq.to_submit += have;
                 ctx->proc->io.pending = true;
                 ctx->proc->io.dirty   = true;
                 if(sq.to_submit > 30 || !lazy) {
                         __cfa_io_flush( ctx->proc );
+                        __cfa_io_flush( ctx->proc, false );
+                }
+        }
 …
+                }
+        }
+        #if defined(IO_URING_IDLE)
+                bool __kernel_read(processor * proc, io_future_t & future, char buf[], int fd) {
+                        $io_context * ctx = proc->io.ctx;
+                        /* paranoid */ verify( ! __preemption_enabled() );
+                        /* paranoid */ verify( proc == __cfaabi_tls.this_processor );
+                        /* paranoid */ verify( ctx );
+                        __u32 idx;
+                        struct io_uring_sqe * sqe;
+                        // We can proceed to the fast path
+                        if( !__alloc(ctx, &idx, 1) ) return false;
+                        // Allocation was successful
+                        __fill( &sqe, 1, &idx, ctx );
+                        sqe->opcode = IORING_OP_READ;
+                        sqe->user_data = (uintptr_t)&future;
+                        sqe->flags = 0;
+                        sqe->ioprio = 0;
+                        sqe->fd = 0;
+                        sqe->off = 0;
+                        sqe->fsync_flags = 0;
+                        sqe->__pad2[0] = 0;
+                        sqe->__pad2[1] = 0;
+                        sqe->__pad2[2] = 0;
+                        sqe->addr = (uintptr_t)buf;
+                        sqe->len = sizeof(uint64_t);
+                        asm volatile("": : :"memory");
+                        /* paranoid */ verify( sqe->user_data == (uintptr_t)&future );
+                        __submit( ctx, &idx, 1, true );
+                        /* paranoid */ verify( proc == __cfaabi_tls.this_processor );
+                        /* paranoid */ verify( ! __preemption_enabled() );
+                }
+        #endif
 #endif

libcfa/src/concurrency/io/setup.cfa

-                      r94647b0
+                      r7770cc8
         void __cfa_io_start( processor * proc ) {}
         void __cfa_io_flush( processor * proc ) {}
+        bool __cfa_io_flush( processor * proc, bool ) {}
         void __cfa_io_stop ( processor * proc ) {}
 …
                 this.ext_sq.empty = true;
                 (this.ext_sq.queue){};
                 __io_uring_setup( this, cl.io.params, proc->idle );
+                __io_uring_setup( this, cl.io.params, proc->idle_fd );
                 __cfadbg_print_safe(io_core, "Kernel I/O : Created ring for io_context %u (%p)\n", this.fd, &this);
+        }
 …
                 cq.cqes = (struct io_uring_cqe *)(((intptr_t)cq.ring_ptr) + params.cq_off.cqes);
+                // Step 4 : eventfd
+                // 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 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);
+                #if !defined(IO_URING_IDLE)
+                        // Step 4 : eventfd
+                        // 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 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);
+                #endif
                 // some paranoid checks

libcfa/src/concurrency/io/types.hfa

-                      r94647b0
+                      r7770cc8
         // Wait for the future to be fulfilled
         bool wait( io_future_t & this ) {
                 return wait(this.self);
+        }
+        bool wait     ( io_future_t & this ) { return wait     (this.self); }
+        void reset    ( io_future_t & this ) { return reset    (this.self); }
+        bool available( io_future_t & this ) { return available(this.self); }
+}

libcfa/src/concurrency/kernel.cfa

-                      r94647b0
+                      r7770cc8
 #include "strstream.hfa"
 #include "device/cpu.hfa"
+#include "io/types.hfa"
 //Private includes
 …
 static void __wake_one(cluster * cltr);
+static void mark_idle (__cluster_proc_list & idles, processor & proc);
+static void idle_sleep(processor * proc, io_future_t & future, char buf[]);
+static bool 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 bool __cfa_io_flush( processor *, bool wait );
 extern void __cfa_io_stop ( processor * );
 static inline bool __maybe_io_drain( processor * );
+#if defined(IO_URING_IDLE) && defined(CFA_HAVE_LINUX_IO_URING_H)
+        extern bool __kernel_read(processor * proc, io_future_t & future, char buf[], int fd);
+#endif
 extern void __disable_interrupts_hard();
 …
         /* paranoid */ verify( __preemption_enabled() );
+}
 //=============================================================================================
 …
         verify(this);
+        io_future_t future; // used for idle sleep when io_uring is present
+        future.self.ptr = 1p;  // mark it as already fulfilled so we know if there is a pending request or not
+        char buf[sizeof(uint64_t)];
         __cfa_io_start( this );
 …
                         if( !readyThread ) {
+                                __cfa_io_flush( this );
+                                __cfa_io_flush( this, false );
                                 readyThread = __next_thread_slow( this->cltr );
+                        }
 …
                                 // Push self to idle stack
                                 mark_idle(this->cltr->procs, * this);
+                                if(!mark_idle(this->cltr->procs, * this)) continue MAIN_LOOP;
                                 // Confirm the ready-queue is empty
 …
+                                }
+                                #if !defined(__CFA_NO_STATISTICS__)
+                                        if(this->print_halts) {
+                                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl());
+                                idle_sleep( this, future, buf );
+                                // We were woken up, remove self from idle
+                                mark_awake(this->cltr->procs, * this);
+                                // DON'T just proceed, start looking again
+                                continue MAIN_LOOP;
+                        }
+                        /* 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(this->io.pending && !this->io.dirty) {
+                                __cfa_io_flush( this, false );
+                        }
+                        #else
+                                #warning new kernel loop
+                        SEARCH: {
+                                /* paranoid */ verify( ! __preemption_enabled() );
+                                // First, lock the scheduler since we are searching for a thread
+                                ready_schedule_lock();
+                                // Try to get the next thread
+                                readyThread = pop_fast( this->cltr );
+                                if(readyThread) { ready_schedule_unlock(); 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, false ); }
+                                // Spin a little on I/O, just in case
+                                for(5) {
+                                        __maybe_io_drain( this );
+                                        readyThread = pop_fast( this->cltr );
+                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+                                }
+                                // no luck, try stealing a few times
+                                for(5) {
+                                        if( __maybe_io_drain( this ) ) {
+                                                readyThread = pop_fast( this->cltr );
+                                        } else {
+                                                readyThread = pop_slow( this->cltr );
+                                        }
+                                #endif
+                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+                                }
+                                // still no luck, search for a thread
+                                readyThread = pop_search( this->cltr );
+                                if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+                                // Don't block if we are done
+                                if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) {
+                                        ready_schedule_unlock();
+                                        break MAIN_LOOP;
+                                }
+                                __STATS( __tls_stats()->ready.sleep.halts++; )
+                                // Push self to idle stack
+                                ready_schedule_unlock();
+                                if(!mark_idle(this->cltr->procs, * this)) goto SEARCH;
+                                ready_schedule_lock();
+                                // Confirm the ready-queue is empty
+                                __maybe_io_drain( this );
+                                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->unique_id, rdtscl()); )
+                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
+                                {
                                         eventfd_t val;
                                         ssize_t ret = read( this->idle, &val, sizeof(val) );
+                                        ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
                                         if(ret < 0) {
                                                 switch((int)errno) {
 …
+                                }
+                                #if !defined(__CFA_NO_STATISTICS__)
+                                        if(this->print_halts) {
+                                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl());
+                                        }
+                                #endif
+                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
                                 // We were woken up, remove self from idle
 …
+                        }
-                        /* 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(this->io.pending && !this->io.dirty) {
-                                __cfa_io_flush( this );
+                        }
-                        #else
-                                #warning new kernel loop
-                        SEARCH: {
-                                /* paranoid */ verify( ! __preemption_enabled() );
-                                // First, lock the scheduler since we are searching for a thread
-                                ready_schedule_lock();
-                                // Try to get the next thread
-                                readyThread = pop_fast( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); 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(5) {
-                                        __maybe_io_drain( this );
-                                        readyThread = pop_fast( this->cltr );
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+                                }
-                                // no luck, try stealing a few times
-                                for(5) {
-                                        if( __maybe_io_drain( this ) ) {
-                                                readyThread = pop_fast( this->cltr );
-                                        } else {
-                                                readyThread = pop_slow( this->cltr );
+                                        }
-                                        if(readyThread) { ready_schedule_unlock(); break SEARCH; }
+                                }
-                                // still no luck, search for a thread
-                                readyThread = pop_search( this->cltr );
-                                if(readyThread) { ready_schedule_unlock(); 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
-                                ready_schedule_unlock();
-                                mark_idle(this->cltr->procs, * this);
-                                ready_schedule_lock();
-                                // Confirm the ready-queue is empty
-                                __maybe_io_drain( this );
-                                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->unique_id, rdtscl()); )
-                                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
+                                {
-                                        eventfd_t val;
-                                        ssize_t ret = read( this->idle, &val, sizeof(val) );
-                                        if(ret < 0) {
-                                                switch((int)errno) {
-                                                case EAGAIN:
-                                                #if EAGAIN != EWOULDBLOCK
-                                                        case EWOULDBLOCK:
-                                                #endif
-                                                case EINTR:
-                                                        // No need to do anything special here, just assume it's a legitimate wake-up
-                                                        break;
-                                                default:
-                                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+                                                }
+                                        }
+                                }
-                                        __STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_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( ! __preemption_enabled() );
 …
                         if(this->io.pending && !this->io.dirty) {
                                 __cfa_io_flush( this );
+                                __cfa_io_flush( this, false );
+                        }
 …
         // Check if there is a sleeping processor
+        processor * p;
+        unsigned idle;
+        unsigned total;
+        [idle, total, p] = query_idles(this->procs);
+        int fd = __atomic_load_n(&this->procs.fd, __ATOMIC_SEQ_CST);
         // If no one is sleeping, we are done
         if( idle == 0 ) return;
+        if( fd == 0 ) return;
         // We found a processor, wake it up
         eventfd_t val;
         val = 1;
         eventfd_write( p->idle, val );
+        eventfd_write( fd, val );
         #if !defined(__CFA_NO_STATISTICS__)
 …
                 eventfd_t val;
                 val = 1;
                 eventfd_write( this->idle, val );
+                eventfd_write( this->idle_fd, val );
         __enable_interrupts_checked();
+}
+static void mark_idle(__cluster_proc_list & this, processor & proc) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        lock( this );
+static void idle_sleep(processor * this, io_future_t & future, char buf[]) {
+        #if !defined(IO_URING_IDLE) || !defined(CFA_HAVE_LINUX_IO_URING_H)
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(this->print_halts) {
+                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl());
+                        }
+                #endif
+                __cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle_fd);
+                {
+                        eventfd_t val;
+                        ssize_t ret = read( this->idle_fd, &val, sizeof(val) );
+                        if(ret < 0) {
+                                switch((int)errno) {
+                                case EAGAIN:
+                                #if EAGAIN != EWOULDBLOCK
+                                        case EWOULDBLOCK:
+                                #endif
+                                case EINTR:
+                                        // No need to do anything special here, just assume it's a legitimate wake-up
+                                        break;
+                                default:
+                                        abort( "KERNEL : internal error, read failure on idle eventfd, error(%d) %s.", (int)errno, strerror( (int)errno ) );
+                                }
+                        }
+                }
+                #if !defined(__CFA_NO_STATISTICS__)
+                        if(this->print_halts) {
+                                __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl());
+                        }
+                #endif
+        #else
+                #if !defined(CFA_HAVE_IORING_OP_READ)
+                        #error this is only implemented if the read is present
+                #endif
+                // Do we already have a pending read
+                if(available(future)) {
+                        // There is no pending read, we need to add one
+                        reset(future);
+                        __kernel_read(this, future, buf, this->idle_fd );
+                }
+                __cfa_io_flush( this, true );
+        #endif
+}
+static bool mark_idle(__cluster_proc_list & this, processor & proc) {
+        /* paranoid */ verify( ! __preemption_enabled() );
+        if(!try_lock( this )) return false;
                 this.idle++;
                 /* paranoid */ verify( this.idle <= this.total );
                 remove(proc);
                 insert_first(this.idles, proc);
+                __atomic_store_n(&this.fd, proc.idle_fd, __ATOMIC_SEQ_CST);
         unlock( this );
         /* paranoid */ verify( ! __preemption_enabled() );
+        return true;
+}
 …
                 remove(proc);
                 insert_last(this.actives, proc);
+                {
+                        int fd = 0;
+                        if(!this.idles`isEmpty) fd = this.idles`first.idle_fd;
+                        __atomic_store_n(&this.fd, fd, __ATOMIC_SEQ_CST);
+                }
         unlock( this );
-        /* paranoid */ verify( ! __preemption_enabled() );
+}
-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);
-                if( 1 == (l % 2) ) { Pause(); continue; }
-                unsigned idle    = this.idle;
-                unsigned total   = this.total;
-                processor * proc = &this.idles`first;
-                // Compiler fence is unnecessary, but gcc-8 and older incorrectly reorder code without it
-                asm volatile("": : :"memory");
-                if(l != __atomic_load_n(&this.lock, __ATOMIC_SEQ_CST)) { Pause(); continue; }
-                return [idle, total, proc];
+        }
-        /* paranoid */ verify( ready_schedule_islocked() );
         /* paranoid */ verify( ! __preemption_enabled() );
+}
 …
                 if(head == tail) return false;
                 #if OLD_MAIN
                 ready_schedule_lock();
                 ret = __cfa_io_drain( proc );
                 ready_schedule_unlock();
+                        ready_schedule_lock();
+                        ret = __cfa_io_drain( proc );
+                        ready_schedule_unlock();
                 #else
                         ret = __cfa_io_drain( proc );
         #endif
+                #endif
         #endif
         return ret;
 …
                         /* paranoid */ verifyf( it, "Unexpected null iterator, at index %u of %u\n", i, count);
                         /* paranoid */ verify( it->local_data->this_stats );
+                        // __print_stats( it->local_data->this_stats, cltr->print_stats, "Processor", it->name, (void*)it );
                         __tally_stats( cltr->stats, it->local_data->this_stats );
                         it = &(*it)`next;
 …
                 // this doesn't solve all problems but does solve many
                 // so it's probably good enough
+                disable_interrupts();
                 uint_fast32_t last_size = ready_mutate_lock();
 …
                 // Unlock the RWlock
                 ready_mutate_unlock( last_size );
+                enable_interrupts();
+        }

libcfa/src/concurrency/kernel.hfa

-                      r94647b0
+                      r7770cc8
         // Idle lock (kernel semaphore)
         int idle;
+        int idle_fd;
         // Termination synchronisation (user semaphore)
 …
 struct __cluster_proc_list {
         // Spin lock protecting the queue
+        volatile uint64_t lock;
+        __spinlock_t lock;
+        // FD to use to wake a processor
+        volatile int fd;
         // Total number of processors

libcfa/src/concurrency/kernel/startup.cfa

-                      r94647b0
+                      r7770cc8
 // Other Forward Declarations
 extern void __wake_proc(processor *);
+extern int cfa_main_returned;                                                   // from interpose.cfa
 //-----------------------------------------------------------------------------
 …
 static void __kernel_shutdown(void) {
+        if(!cfa_main_returned) return;
         /* paranoid */ verify( __preemption_enabled() );
         disable_interrupts();
 …
         this.local_data = 0p;
         this.idle = eventfd(0, 0);
         if (idle < 0) {
+        this.idle_fd = eventfd(0, 0);
+        if (idle_fd < 0) {
                 abort("KERNEL ERROR: PROCESSOR EVENTFD - %s\n", strerror(errno));
+        }
 …
 // Not a ctor, it just preps the destruction but should not destroy members
 static void deinit(processor & this) {
         close(this.idle);
+        close(this.idle_fd);
+}
 …
 // Cluster
 static void ?{}(__cluster_proc_list & this) {
         this.lock  = 0;
+        this.fd    = 0;
         this.idle  = 0;
         this.total = 0;

libcfa/src/concurrency/kernel_private.hfa

-                      r94647b0
+                      r7770cc8
+}
+// #define IO_URING_IDLE
 //-----------------------------------------------------------------------------
 // Scheduler
 …
         __atomic_store_n(ll, (bool)false, __ATOMIC_RELEASE);
+}
 //-----------------------------------------------------------------------
 …
         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() );
+        lock( this.lock __cfaabi_dbg_ctx2 );
+        /* paranoid */ verify( ! __preemption_enabled() );
+}
+static inline bool try_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();
+        if(try_lock( this.lock __cfaabi_dbg_ctx2 )) {
+                // success
+                /* paranoid */ verify( ! __preemption_enabled() );
+                return true;
+        }
+        // failed to lock
+        ready_schedule_unlock();
+        /* paranoid */ verify( ! __preemption_enabled() );
+        return false;
+}
 …
         /* 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 );
+        unlock(this.lock);
         // Release the global lock, which we acquired when locking

libcfa/src/concurrency/monitor.hfa

-                      r94647b0
+                      r7770cc8
         free( th );
+}
+static inline forall( T & | sized(T) | { void ^?{}( T & mutex ); } )
+void adelete( T arr[] ) {
+        if ( arr ) {                                                                            // ignore null
+                size_t dim = malloc_size( arr ) / sizeof( T );
+                for ( int i = dim - 1; i >= 0; i -= 1 ) {               // reverse allocation order, must be unsigned
+                        ^(arr[i]){};                                                            // run destructor
+                } // for
+                free( arr );
+        } // if
+} // adelete
 //-----------------------------------------------------------------------------

libcfa/src/concurrency/mutex_stmt.hfa

-                      r94647b0
+                      r7770cc8
 #include "bits/algorithm.hfa"
+#include <assert.h>
+#include "invoke.h"
+#include "stdlib.hfa"
+#include <stdio.h>
+#include "bits/defs.hfa"
 //-----------------------------------------------------------------------------

libcfa/src/device/cpu.cfa

r94647b0	r7770cc8
144	144	// Count number of cpus in the system
145	145	static int count_cpus(void) {
146		const char * fpath = "/sys/devices/system/cpu/~~present~~";
	146	const char * fpath = "/sys/devices/system/cpu/online";
147	147	int fd = open(fpath, 0, O_RDONLY);
148	148	/* paranoid */ verifyf(fd >= 0, "Could not open file %s", fpath);

libcfa/src/fstream.cfa

-                      r94647b0
+                      r7770cc8
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Sep 21 21:51:38 2021
 // Update Count     : 460
+// Last Modified On : Sun Oct 10 11:23:05 2021
+// Update Count     : 512
 //
 …
 #define IO_MSG "I/O error: "
+void ?{}( ofstream & os, void * file ) with(os) {
+// private
+void ?{}( ofstream & os, void * file ) with( os ) {
         file$ = file;
         sepDefault$ = true;
 …
         prt$ = false;
         sawNL$ = false;
-        acquired$ = false;
         sepSetCur$( os, sepGet( os ) );
         sepSet( 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; }
+inline bool sepPrt$( ofstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+inline void sepReset$( ofstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+inline void sepReset$( ofstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+inline const char * sepGetCur$( ofstream & os ) { return os.sepCur$; }
+inline void sepSetCur$( ofstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+inline bool getNL$( ofstream & os ) { return os.sawNL$; }
+inline void setNL$( ofstream & os, bool state ) { os.sawNL$ = state; }
+inline bool getANL$( ofstream & os ) { return os.nlOnOff$; }
+inline bool getPrt$( ofstream & os ) { return os.prt$; }
+inline void setPrt$( ofstream & os, bool state ) { os.prt$ = state; }
+inline void lock( ofstream & os ) with( os ) {  lock( os.lock$ ); }
+inline void unlock( ofstream & os ) { unlock( os.lock$ ); }
 // public
 void ?{}( ofstream & os ) { os.file$ = 0p; }
+void ?{}( ofstream & os, const char name[], const char mode[] ) {
+        open( os, name, mode );
+} // ?{}
+void ?{}( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // ?{}
+void ^?{}( ofstream & os ) {
+        close( os );
+} // ^?{}
+void ?{}( ofstream & os, const char name[], const char mode[] ) { open( os, name, mode ); }
+void ?{}( ofstream & os, const char name[] ) { open( os, name, "w" ); }
+void ^?{}( ofstream & os ) { close( os ); }
 void sepOn( ofstream & os ) { os.sepOnOff$ = ! getNL$( os ); }
 …
         if ( &os == &exit ) exit( EXIT_FAILURE );
         if ( &os == &abort ) abort();
-        if ( os.acquired$ ) { os.acquired$ = false; release( os ); }
 } // ends
+bool fail( ofstream & os ) {
+        return os.file$ == 0 || ferror( (FILE *)(os.file$) );
+} // fail
+void clear( ofstream & os ) {
+        clearerr( (FILE *)(os.file$) );
+} // clear
+int flush( ofstream & os ) {
+        return fflush( (FILE *)(os.file$) );
+} // flush
+bool fail( ofstream & os ) { return os.file$ == 0 || ferror( (FILE *)(os.file$) ); }
+void clear( ofstream & os ) { clearerr( (FILE *)(os.file$) ); }
+int flush( ofstream & os ) { return fflush( (FILE *)(os.file$) ); }
 void open( ofstream & os, const char name[], const char mode[] ) {
+        FILE * file = fopen( name, mode );
+        FILE * file;
+    for ( cnt; 10 ) {
+                errno = 0;
+                file = fopen( name, mode );
+          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
+    } // for
         if ( file == 0p ) {
                 throw (Open_Failure){ os };
 …
 } // open
+void open( ofstream & os, const char name[] ) {
+        open( os, name, "w" );
+} // open
+void close( ofstream & os ) with(os) {
+void open( ofstream & os, const char name[] ) { open( os, name, "w" ); }
+void close( ofstream & os ) with( os ) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdout || (FILE *)(file$) == (FILE *)stderr ) return;
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
+        int ret;
+    for ( cnt; 10 ) {
+                errno = 0;
+                ret = fclose( (FILE *)(file$) );
+          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream open EINTR spinning exceeded" );
+    } // for
+        if ( ret == EOF ) {
                 throw (Close_Failure){ os };
                 // abort | IO_MSG "close output" | nl | strerror( errno );
         } // if
         file$ = 0p;
+        file$ = 0p;                                                                                     // safety after close
 } // close
 …
         va_list args;
         va_start( args, format );
+        int len = vfprintf( (FILE *)(os.file$), format, args );
+        int len;
+    for ( cnt; 10 ) {
+                errno = 0;
+                len = vfprintf( (FILE *)(os.file$), format, args );
+          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ofstream fmt EINTR spinning exceeded" );
+    } // for
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(os.file$) ) ) {
 …
 } // fmt
-inline void acquire( ofstream & os ) with(os) {
-        lock( lock$ );                                                                          // may increase recursive lock
-        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
-        else unlock( lock$ );                                                           // unwind recursive lock at start
-} // acquire
-inline void release( ofstream & os ) {
-        unlock( os.lock$ );
-} // release
-void ?{}( osacquire & acq, ofstream & os ) { lock( os.lock$ ); &acq.os = &os; }
-void ^?{}( osacquire & acq ) { release( acq.os ); }
 static ofstream soutFile = { (FILE *)stdout };
 ofstream & sout = soutFile, & stdout = soutFile;
 …
         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
 …
 // private
 void ?{}( ifstream & is, void * file ) with(is) {
+void ?{}( ifstream & is, void * file ) with( is ) {
         file$ = file;
         nlOnOff$ = false;
+        acquired$ = false;
+} // ?{}
+} // ?{}
+bool getANL$( ifstream & os ) { return os.nlOnOff$; }
+inline void lock( ifstream & os ) with( os ) { lock( os.lock$ ); }
+inline void unlock( ifstream & os ) { unlock( os.lock$ ); }
 // public
 void ?{}( ifstream & is ) { is.file$ = 0p; }
+void ?{}( ifstream & is, const char name[], const char mode[] ) {
+        open( is, name, mode );
+} // ?{}
+void ?{}( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // ?{}
+void ^?{}( ifstream & is ) {
+        close( is );
+} // ^?{}
+void ?{}( ifstream & is, const char name[], const char mode[] ) { open( is, name, mode ); }
+void ?{}( ifstream & is, const char name[] ) { open( is, name, "r" ); }
+void ^?{}( ifstream & is ) { close( is ); }
+bool fail( ifstream & is ) { return is.file$ == 0p || ferror( (FILE *)(is.file$) ); }
+void clear( ifstream & is ) { clearerr( (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 clear( ifstream & is ) {
+        clearerr( (FILE *)(is.file$) );
+} // clear
+void ends( ifstream & is ) {
+        if ( is.acquired$ ) { is.acquired$ = false; release( is ); }
+} // ends
+bool eof( ifstream & is ) {
+        return feof( (FILE *)(is.file$) );
+} // eof
+void ends( ifstream & is ) {}
+bool eof( ifstream & is ) { return feof( (FILE *)(is.file$) ) != 0; }
 void open( ifstream & is, const char name[], const char mode[] ) {
+        FILE * file = fopen( name, mode );
+        FILE * file;
+    for ( cnt; 10 ) {
+                errno = 0;
+                file = fopen( name, mode );
+          if ( file != 0p || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ifstream open EINTR spinning exceeded" );
+    } // for
         if ( file == 0p ) {
                 throw (Open_Failure){ is };
 …
 } // open
+void open( ifstream & is, const char name[] ) {
+        open( is, name, "r" );
+} // open
+void close( ifstream & is ) with(is) {
+void open( ifstream & is, const char name[] ) { open( is, name, "r" ); }
+void close( ifstream & is ) with( is ) {
   if ( (FILE *)(file$) == 0p ) return;
   if ( (FILE *)(file$) == (FILE *)stdin ) return;
+        if ( fclose( (FILE *)(file$) ) == EOF ) {
+        int ret;
+    for ( cnt; 10 ) {
+                errno = 0;
+                ret = fclose( (FILE *)(file$) );
+          if ( ret != EOF || errno != EINTR ) break;            // timer interrupt ?
+          if ( cnt == 9 ) abort( "ifstream close EINTR spinning exceeded" );
+    } // for
+        if ( ret == EOF ) {
                 throw (Close_Failure){ is };
                 // abort | IO_MSG "close input" | nl | strerror( errno );
         } // if
         file$ = 0p;
+        file$ = 0p;                                                                                     // safety after close
 } // close
 …
 int fmt( ifstream & is, const char format[], ... ) {
         va_list args;
         va_start( args, format );
+        int len = vfscanf( (FILE *)(is.file$), format, args );
+        int len;
+    for () {                                                                                    // no check for EINTR limit waiting for keyboard input
+                errno = 0;
+                len = vfscanf( (FILE *)(is.file$), format, args );
+          if ( len != EOF || errno != EINTR ) break;            // timer interrupt ?
+    } // for
         if ( len == EOF ) {
                 if ( ferror( (FILE *)(is.file$) ) ) {
 …
         return len;
 } // fmt
-inline void acquire( ifstream & is ) with(is) {
-        lock( lock$ );                                                                          // may increase recursive lock
-        if ( ! acquired$ ) acquired$ = true;                            // not locked ?
-        else unlock( lock$ );                                                           // unwind recursive lock at start
-} // acquire
-inline void release( ifstream & is ) {
-        unlock( is.lock$ );
-} // release
-void ?{}( isacquire & acq, ifstream & is ) { lock( is.lock$ ); &acq.is = &is; }
-void ^?{}( isacquire & acq ) { release( acq.is ); }
 static ifstream sinFile = { (FILE *)stdin };

libcfa/src/fstream.hfa

-                      r94647b0
+                      r7770cc8
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jul 28 07:35:50 2021
 // Update Count     : 234
+// Last Modified On : Sun Oct 10 09:37:32 2021
+// Update Count     : 243
 //
 …
         char tupleSeparator$[ofstream_sepSize];
         multiple_acquisition_lock lock$;
-        bool acquired$;
 }; // ofstream
 …
 bool getPrt$( ofstream & );
 void setPrt$( ofstream &, bool );
+void lock( ofstream & );
+void unlock( ofstream & );
 // public
 …
 void open( ofstream &, const char name[] );
 void close( ofstream & );
 ofstream & write( ofstream &, const char data[], size_t size );
-void acquire( ofstream & );
-void release( ofstream & );
-void lock( ofstream & );
-void unlock( ofstream & );
-struct osacquire {
-        ofstream & os;
-};
-void ?{}( osacquire & acq, ofstream & );
-void ^?{}( osacquire & acq );
 void ?{}( ofstream & );
 …
         bool nlOnOff$;
         multiple_acquisition_lock lock$;
-        bool acquired$;
 }; // ifstream
 // Satisfies istream
+// private
+bool getANL$( ifstream & );
+void lock( ifstream & );
+void unlock( ifstream & );
 // public
 void nlOn( ifstream & );
 void nlOff( ifstream & );
-bool getANL( ifstream & );
 void ends( ifstream & );
 int fmt( ifstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 …
 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 );
-void acquire( ifstream & is );
-void release( ifstream & is );
-struct isacquire {
-        ifstream & is;
-};
-void ?{}( isacquire & acq, ifstream & is );
-void ^?{}( isacquire & acq );
 void ?{}( ifstream & is );

libcfa/src/heap.cfa

r94647b0	r7770cc8
102	102	} // prtUnfreed
103	103
104		extern int cfa_main_returned; // from ~~bootloader.cf~~
	104	extern int cfa_main_returned; // from interpose.cfa
105	105	extern "C" {
106	106	void heapAppStart() { // called by __cfaabi_appready_startup

libcfa/src/interpose.cfa

-                      r94647b0
+                      r7770cc8
 } __cabi_libc;
+int cfa_main_returned;
 extern "C" {
         void __cfaabi_interpose_startup( void ) {
                 const char *version = 0p;
+                cfa_main_returned = 0;
                 preload_libgcc();

libcfa/src/iostream.cfa

-                      r94647b0
+                      r7770cc8
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat May 15 09:39:21 2021
 // Update Count     : 1342
+// Last Modified On : Sun Oct 10 09:28:17 2021
+// Update Count     : 1345
 //
 …
                 return os;
         } // nlOff
-} // distribution
-forall( ostype & | ostream( ostype ) ) {
-        ostype & acquire( ostype & os ) {
-                acquire( os );                                                                  // call void returning
-                return os;
-        } // acquire
 } // distribution
 …
                         fmt( is, "%c", &temp );                                         // must pass pointer through varg to fmt
                         // do not overwrite parameter with newline unless appropriate
                         if ( temp != '\n' || getANL( is ) ) { c = temp; break; }
+                        if ( temp != '\n' || getANL$( is ) ) { c = temp; break; }
                         if ( eof( is ) ) break;
                 } // for
 …
                 return is;
         } // nlOff
-} // distribution
-forall( istype & | istream( istype ) ) {
-        istype & acquire( istype & is ) {
-                acquire( is );                                                                  // call void returning
-                return is;
-        } // acquire
 } // distribution

libcfa/src/iostream.hfa

-                      r94647b0
+                      r7770cc8
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Apr 28 20:37:56 2021
 // Update Count     : 401
+// Last Modified On : Sun Oct 10 10:02:07 2021
+// Update Count     : 407
 //
 …
         void close( ostype & );
         ostype & write( ostype &, const char [], size_t );
-        void acquire( ostype & );                                                       // concurrent access
 }; // ostream
 …
         ostype & nlOn( ostype & );
         ostype & nlOff( ostype & );
-} // distribution
-forall( ostype & | ostream( ostype ) ) {
-        ostype & acquire( ostype & );
 } // distribution
 …
 trait basic_istream( istype & ) {
+        bool getANL( istype & );                                                        // get scan newline (on/off)
+        // private
+        bool getANL$( istype & );                                                       // get scan newline (on/off)
+        // public
         void nlOn( istype & );                                                          // read newline
         void nlOff( istype & );                                                         // scan newline
         void ends( istype & os );                                                       // end of output statement
         int fmt( istype &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 …
         void close( istype & is );
         istype & read( istype &, char [], size_t );
-        void acquire( istype & );                                                       // concurrent access
 }; // istream
 …
 } // distribution
-forall( istype & | istream( istype ) ) {
-        istype & acquire( istype & );
-} // distribution
 // *********************************** manipulators ***********************************

libcfa/src/strstream.cfa

-                      r94647b0
+                      r7770cc8
 // Created On       : Thu Apr 22 22:24:35 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 27 20:59:53 2021
 // Update Count     : 78
+// Last Modified On : Sun Oct 10 16:13:20 2021
+// Update Count     : 101
 //
 #include "strstream.hfa"
+#include "fstream.hfa"                                                                  // abort
 #include <stdio.h>                                                                              // vsnprintf
 …
 // private
 bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
 void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
 void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
 const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
 void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
 bool getNL$( ostrstream & os ) { return os.sawNL$; }
 void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
 bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
 bool getPrt$( ostrstream & os ) { return os.prt$; }
 void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
+inline bool sepPrt$( ostrstream & os ) { setNL$( os, false ); return os.sepOnOff$; }
+inline void sepReset$( ostrstream & os ) { os.sepOnOff$ = os.sepDefault$; }
+inline void sepReset$( ostrstream & os, bool reset ) { os.sepDefault$ = reset; os.sepOnOff$ = os.sepDefault$; }
+inline const char * sepGetCur$( ostrstream & os ) { return os.sepCur$; }
+inline void sepSetCur$( ostrstream & os, const char sepCur[] ) { os.sepCur$ = sepCur; }
+inline bool getNL$( ostrstream & os ) { return os.sawNL$; }
+inline void setNL$( ostrstream & os, bool state ) { os.sawNL$ = state; }
+inline bool getANL$( ostrstream & os ) { return os.nlOnOff$; }
+inline bool getPrt$( ostrstream & os ) { return os.prt$; }
+inline void setPrt$( ostrstream & os, bool state ) { os.prt$ = state; }
 // public
 …
 // *********************************** istrstream ***********************************
+// private
+bool getANL$( istrstream & is ) { return is.nlOnOff$; }
 // public
 …
 } // ?{}
-bool getANL( istrstream & is ) { return is.nlOnOff$; }
 void nlOn( istrstream & is ) { is.nlOnOff$ = true; }
 void nlOff( istrstream & is ) { is.nlOnOff$ = false; }
 void ends( istrstream & is ) {
+} // ends
+void ends( istrstream & is ) {}
+bool eof( istrstream & is ) { return false; }
+int eof( istrstream & is ) {
+        return 0;
+} // eof
+int fmt( istrstream & is, const char format[], ... ) with(is) {
+        va_list args;
+        va_start( args, format );
+        // THIS DOES NOT WORK BECAUSE VSSCANF RETURNS NUMBER OF VALUES READ VERSUS BUFFER POSITION SCANNED.
+        int len = vsscanf( buf$ + cursor$, format, args );
+        va_end( args );
+        if ( len == EOF ) {
+                abort | IO_MSG "invalid read";
+        } // if
+        // SKULLDUGGERY: This hack skips over characters read by vsscanf by moving to the next whitespace but it does not
+        // handle C reads with wdi manipulators that leave the cursor at a non-whitespace character.
+        for ( ; buf$[cursor$] != ' ' && buf$[cursor$] != '\t' && buf$[cursor$] != '\0'; cursor$ += 1 ) {
+                //printf( "X \'%c\'\n", buf$[cursor$] );
+        } // for
+        if ( buf$[cursor$] != '\0' ) cursor$ += 1;      // advance to whitespace
+        return len;
+} // fmt
 istrstream &ungetc( istrstream & is, char c ) {
 …
 } // ungetc
-int fmt( istrstream & is, const char format[], ... ) {
-        va_list args;
-        va_start( args, format );
-        // This does not work because vsscanf does not return buffer position.
-        int len = vsscanf( is.buf$ + is.cursor$, format, args );
-        va_end( args );
-        if ( len == EOF ) {
-                int j;
-                printf( "X %d%n\n", len, &j );
-        } // if
-        is.cursor$ += len;
-        return len;
-} // fmt
 // Local Variables: //
 // tab-width: 4 //

libcfa/src/strstream.hfa

-                      r94647b0
+                      r7770cc8
 // Created On       : Thu Apr 22 22:20:59 2021
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Tue Apr 27 20:58:50 2021
 // Update Count     : 41
+// Last Modified On : Sun Oct 10 10:14:22 2021
+// Update Count     : 47
 //
 …
 // Satisfies basic_istream
+// private
+bool getANL$( istrstream & );
 // public
-bool getANL( istrstream & );
 void nlOn( istrstream & );
 void nlOff( istrstream & );
 void ends( istrstream & );
 int fmt( istrstream &, const char format[], ... ) __attribute__(( format(scanf, 2, 3) ));
 istrstream & ungetc( istrstream & is, char c );
 int eof( istrstream & is );
+istrstream & ungetc( istrstream &, char );
+bool eof( istrstream & );
 void ?{}( istrstream & is, char buf[] );
+void ?{}( istrstream &, char buf[] );
 // Local Variables: //

src/AST/Convert.cpp

-                      r94647b0
+                      r7770cc8
         const ast::Expr * visit( const ast::StmtExpr * node ) override final {
-                auto stmts = node->stmts;
-                // disable sharing between multiple StmtExprs explicitly.
-                // this should no longer be true.
                 auto rslt = new StmtExpr(
                         get<CompoundStmt>().accept1(stmts)
+                        get<CompoundStmt>().accept1(node->stmts)
                 );
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
+                if (node->resultExpr) {
+                        // this MUST be found by children visit
+                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
+                }
+                // is this even used after convert?
+                //if (tmp->resultExpr) {
+                //      // this MUST be found by children visit
+                //      rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(tmp->resultExpr));
+                //}
                 auto expr = visitBaseExpr( node, rslt );
 …
 std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit ) {
+        // Copy values from the global store to the local static variables.
+        ast::sizeType = translationUnit.global.sizeType;
+        ast::dereferenceOperator = translationUnit.global.dereference;
+        ast::dtorStruct = translationUnit.global.dtorStruct;
+        ast::dtorStructDestroy = translationUnit.global.dtorDestroy;
         ConverterNewToOld c;
         std::list< Declaration * > decls;

src/AST/Copy.hpp

-                      r94647b0
+                      r7770cc8
 // Created On       : Wed Jul 10 16:13:00 2019
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jun 19 16:43:00 2020
 // Update Count     : 1
+// Last Modified On : Thr Nov 11  9:22:00 2021
+// Update Count     : 2
 //
 #pragma once
+#include "Decl.hpp"
+#include "Expr.hpp"
+#include "Pass.hpp"
+#include "Stmt.hpp"
+#include "Type.hpp"
+#include <unordered_set>
+#include <unordered_map>
+#include "Node.hpp"
+#include <cassert>
 namespace ast {
 …
  */
+class DeepCopyCore {
+        std::unordered_map< const Node *, const Node * > nodeCache;
+        std::unordered_set< readonly<Node> * > readonlyCache;
+        template<typename node_t>
+        void readonlyInsert( const readonly<node_t> * ptrptr ) {
+                readonlyCache.insert( (readonly<Node> *) ptrptr );
+        }
+public:
+        template<typename node_t>
+        const node_t * previsit( const node_t * node ) {
+                const node_t * copy = shallowCopy( node );
+                nodeCache.insert( std::make_pair( node, copy ) );
+                return copy;
+        }
+        void postvisit( const AggregateDecl * node ) {
+                readonlyInsert( &node->parent );
+        }
+        void postvisit( const StructInstType * node ) {
+                readonlyInsert( &node->base );
+        }
+        void postvisit( const UnionInstType * node ) {
+                readonlyInsert( &node->base );
+        }
+        void postvisit( const EnumInstType * node ) {
+                readonlyInsert( &node->base );
+        }
+        void postvisit( const TraitInstType * node ) {
+                readonlyInsert( &node->base );
+        }
+        void postvisit( const TypeInstType * node ) {
+                readonlyInsert( &node->base );
+        }
+        void postvisit( const ImplicitCtorDtorStmt * node ) {
+                readonlyInsert( (const readonly<Stmt> *) &node->callStmt );
+        }
+        void postvisit( const MemberExpr * node ) {
+                readonlyInsert( &node->member );
+        }
+        void postvisit( const VariableExpr * node ) {
+                readonlyInsert( &node->var );
+        }
+        void postvisit( const OffsetofExpr * node ) {
+                readonlyInsert( &node->member );
+        }
+        void postvisit( const DeletedExpr * node ) {
+                readonlyInsert( &node->deleteStmt );
+        }
+        void readonlyUpdates() {
+                for ( readonly<Node> * ptr : readonlyCache ) {
+                        auto it = nodeCache.find( ptr->get() );
+                        if ( nodeCache.end() != it ) {
+                                *ptr = it->second;
+                        }
+                }
+        }
+};
+// Implementations:
 template<typename node_t>
 node_t * shallowCopy( const node_t * localRoot ) {
 …
 template<typename node_t>
 node_t * deepCopy( const node_t * localRoot ) {
+        Pass< DeepCopyCore > dc;
+        node_t const * newRoot = localRoot->accept( dc );
+        dc.core.readonlyUpdates();
+        return const_cast< node_t * >( newRoot );
+        return strict_dynamic_cast<node_t *>( deepCopy<Node>( localRoot ) );
+}
+template<>
+Node * deepCopy<Node>( const Node * localRoot );
+}

src/AST/Decl.hpp

-                      r94647b0
+                      r7770cc8
         // declared type, derived from parameter declarations
         ptr<FunctionType> type;
+        /// Null for the forward declaration of a function.
         ptr<CompoundStmt> stmts;
         std::vector< ptr<Expr> > withExprs;
 …
         : AggregateDecl( loc, name, std::move(attrs), linkage ), kind( kind ) {}
         bool is_coroutine() { return kind == Coroutine; }
         bool is_generator() { return kind == Generator; }
         bool is_monitor  () { return kind == Monitor  ; }
         bool is_thread   () { return kind == Thread   ; }
+        bool is_coroutine() const { return kind == Coroutine; }
+        bool is_generator() const { return kind == Generator; }
+        bool is_monitor  () const { return kind == Monitor  ; }
+        bool is_thread   () const { return kind == Thread   ; }
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Init.hpp

r94647b0	r7770cc8
98	98	const_iterator begin() const { return initializers.begin(); }
99	99	const_iterator end() const { return initializers.end(); }
	100	size_t size() const { return initializers.size(); }
100	101
101	102	const Init * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Pass.hpp

-                      r94647b0
+                      r7770cc8
         static auto read( node_type const * node, Args&&... args ) {
                 Pass<core_t> visitor( std::forward<Args>( args )... );
                 node_type const * temp = node->accept( visitor );
+                auto const * temp = node->accept( visitor );
                 assert( temp == node );
                 return visitor.get_result();
 …
         static auto read( node_type const * node ) {
                 Pass<core_t> visitor;
                 node_type const * temp = node->accept( visitor );
+                auto const * temp = node->accept( visitor );
                 assert( temp == node );
                 return visitor.get_result();
 …
         /// When this node is finished being visited, restore the value of a variable
+        /// You may assign to the return value to set the new value in the same statement.
         template< typename T >
         void GuardValue( T& val ) {
+        T& GuardValue( T& val ) {
                 at_cleanup( [ val ]( void * newVal ) {
                         * static_cast< T * >( newVal ) = val;
                 }, static_cast< void * >( & val ) );
+                return val;
+        }
 …
 };
+/// Used to get a pointer to the wrapping TranslationUnit.
+struct WithConstTranslationUnit {
+        const TranslationUnit * translationUnit = nullptr;
+        const TranslationUnit & transUnit() const {
+                assertf( translationUnit, "WithConstTranslationUnit not set-up." );
+                return *translationUnit;
+        }
+};
+}

src/AST/Pass.impl.hpp

-                      r94647b0
+                      r7770cc8
 template< typename core_t >
 inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
+        return ast::accept_all( unit.decls, visitor );
+        if ( auto ptr = __pass::translation_unit::get_cptr( visitor.core, 0 ) ) {
+                ValueGuard<const TranslationUnit *> guard( *ptr );
+                *ptr = &unit;
+                return ast::accept_all( unit.decls, visitor );
+        } else {
+                return ast::accept_all( unit.decls, visitor );
+        }
+}

src/AST/Pass.proto.hpp

-                      r94647b0
+                      r7770cc8
         } // namespace forall
+        // For passes that need access to the global context. Sreaches `translationUnit`
+        namespace translation_unit {
+                template<typename core_t>
+                static inline auto get_cptr( core_t & core, int )
+                                -> decltype( &core.translationUnit ) {
+                        return &core.translationUnit;
+                }
+                template<typename core_t>
+                static inline const TranslationUnit ** get_cptr( core_t &, long ) {
+                        return nullptr;
+                }
+        }
         template<typename core_t>
         static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {

src/AST/Stmt.hpp

r94647b0	r7770cc8
175	175	class CaseStmt final : public Stmt {
176	176	public:
	177	/// Null for the default label.
177	178	ptr<Expr> cond;
178	179	std::vector<ptr<Stmt>> stmts;

src/AST/TranslationUnit.hpp

-                      r94647b0
+                      r7770cc8
         std::list< ptr< Decl > > decls;
         struct Globals {
+        struct Global {
                 std::map< UniqueId, Decl * > idMap;
                 const Type * sizeType;
+                ptr<Type> sizeType;
                 const FunctionDecl * dereference;
                 const StructDecl * dtorStruct;

src/AST/module.mk

r94647b0	r7770cc8
24	24	AST/Convert.cpp \
25	25	AST/Convert.hpp \
	26	AST/Copy.cpp \
26	27	AST/Copy.hpp \
27	28	AST/CVQualifiers.hpp \

src/AST/porting.md

r94647b0	r7770cc8
98	98	* `Initializer` => `ast::Init`
99	99	* `Statement` => `ast::Stmt`
	100	* `ReferenceToType` => `ast::BaseInstType`
100	101	* any field names should follow a similar renaming
101	102	* because they don't really belong to `Type` (and for consistency with `Linkage::Spec`):

src/CodeGen/FixMain.cc

-                      r94647b0
+                      r7770cc8
 #include <string>                  // for operator<<
+#include "AST/Decl.hpp"
+#include "AST/Type.hpp"
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "CodeGen/GenType.h"       // for GenType
 …
 namespace CodeGen {
+namespace {
+struct FindMainCore {
+        FunctionDecl * main_signature = nullptr;
+        void previsit( FunctionDecl * decl ) {
+                if ( FixMain::isMain( decl ) ) {
+                        if ( main_signature ) {
+                                SemanticError( decl, "Multiple definition of main routine\n" );
+                        }
+                        main_signature = decl;
+                }
+        }
+};
+}
         bool FixMain::replace_main = false;
-        std::unique_ptr<FunctionDecl> FixMain::main_signature = nullptr;
         template<typename container>
 …
+        }
+        void FixMain::registerMain(FunctionDecl* functionDecl)
+        {
+                if(main_signature) {
+                        SemanticError(functionDecl, "Multiple definition of main routine\n");
+                }
+                main_signature.reset( functionDecl->clone() );
+        }
+        void FixMain::fix( std::list< Declaration * > & translationUnit,
+                        std::ostream &os, const char* bootloader_filename ) {
+                PassVisitor< FindMainCore > main_finder;
+                acceptAll( translationUnit, main_finder );
+                FunctionDecl * main_signature = main_finder.pass.main_signature;
-        void FixMain::fix(std::ostream &os, const char* bootloader_filename) {
                 if( main_signature ) {
                         os << "static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return ";
                         main_signature->mangleName = SymTab::Mangler::mangle(main_signature.get());
+                        main_signature->mangleName = SymTab::Mangler::mangle(main_signature);
                         os << main_signature->get_scopedMangleName() << "(";
 …
+                }
+        }
+namespace {
+ObjectDecl * signedIntObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr );
+}
+ObjectDecl * charStarObj() {
+        return new ObjectDecl(
+                "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
+                new PointerType( Type::Qualifiers(),
+                        new PointerType( Type::Qualifiers(),
+                                new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
+                nullptr );
+}
+std::string create_mangled_main_function_name( FunctionType * function_type ) {
+        std::unique_ptr<FunctionDecl> decl( new FunctionDecl(
+                "main", Type::StorageClasses(), LinkageSpec::Cforall,
+                function_type, nullptr ) );
+        return SymTab::Mangler::mangle( decl.get() );
+}
+std::string mangled_0_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), true );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        return create_mangled_main_function_name( main_type );
+}
+std::string mangled_2_argument_main() {
+        FunctionType* main_type = new FunctionType( Type::Qualifiers(), false );
+        main_type->get_returnVals().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( signedIntObj() );
+        main_type->get_parameters().push_back( charStarObj() );
+        return create_mangled_main_function_name( main_type );
+}
+bool is_main( const std::string & mangled_name ) {
+        // This breaks if you move it out of the function.
+        static const std::string mangled_mains[] = {
+                mangled_0_argument_main(),
+                mangled_2_argument_main(),
+                //mangled_3_argument_main(),
+        };
+        for ( auto main_name : mangled_mains ) {
+                if ( main_name == mangled_name ) return true;
+        }
+        return false;
+}
+} // namespace
+bool FixMain::isMain( FunctionDecl * decl ) {
+        if ( std::string("main") != decl->name ) {
+                return false;
+        }
+        return is_main( SymTab::Mangler::mangle( decl, true, true ) );
+}
+bool FixMain::isMain( const ast::FunctionDecl * decl ) {
+        if ( std::string("main") != decl->name ) {
+                return false;
+        }
+        return is_main( Mangle::mangle( decl, Mangle::Type ) );
+}
 };

src/CodeGen/FixMain.h

-                      r94647b0
+                      r7770cc8
 // Author           : Thierry Delisle
 // Created On       : Thr Jan 12 14:11:09 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sun Feb 16 03:24:32 2020
 // Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 29 16:20:00 2021
+// Update Count     : 8
 //
 …
 #include <iosfwd>
 #include <memory>
+#include <list>
 #include "SynTree/LinkageSpec.h"
+class Declaration;
 class FunctionDecl;
+namespace ast {
+        class FunctionDecl;
+}
 namespace CodeGen {
-        class FixMain {
-          public :
-                static inline LinkageSpec::Spec mainLinkage() {
-                        return replace_main ? LinkageSpec::Cforall : LinkageSpec::C;
+                }
-                static inline void setReplaceMain(bool val) {
-                        replace_main = val;
+                }
+                static void registerMain(FunctionDecl* val);
+class FixMain {
+public :
+        static inline LinkageSpec::Spec mainLinkage() {
+                return replace_main ? LinkageSpec::Cforall : LinkageSpec::C;
+        }
+                static void fix(std::ostream &os, const char* bootloader_filename);
+        static inline void setReplaceMain(bool val) {
+                replace_main = val;
+        }
+          private:
+                static bool replace_main;
+                static std::unique_ptr<FunctionDecl> main_signature;
+        };
+        static bool isMain(FunctionDecl* decl);
+        static bool isMain(const ast::FunctionDecl * decl);
+        static void fix( std::list< Declaration * > & decls,
+                        std::ostream &os, const char* bootloader_filename );
+private:
+        static bool replace_main;
+};
 } // namespace CodeGen

src/CodeGen/FixNames.cc

-                      r94647b0
+                      r7770cc8
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:39:14 2019
 // Update Count     : 21
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 29 15:49:00 2021
+// Update Count     : 23
 //
 …
 #include <string>                  // for string, operator!=, operator==
+#include "AST/Chain.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Pass.hpp"
 #include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 …
         };
-        std::string mangle_main() {
-                FunctionType* main_type;
-                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall,
-                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), true ), nullptr )
-                                };
-                main_type->get_returnVals().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
-                );
-                auto && name = SymTab::Mangler::mangle( mainDecl.get() );
-                // std::cerr << name << std::endl;
-                return std::move(name);
+        }
-        std::string mangle_main_args() {
-                FunctionType* main_type;
-                std::unique_ptr<FunctionDecl> mainDecl { new FunctionDecl( "main", Type::StorageClasses(), LinkageSpec::Cforall,
-                                                                                                                                   main_type = new FunctionType( Type::Qualifiers(), false ), nullptr )
-                                };
-                main_type->get_returnVals().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
-                );
-                main_type->get_parameters().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), nullptr )
-                );
-                main_type->get_parameters().push_back(
-                        new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0,
-                        new PointerType( Type::Qualifiers(), new PointerType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Char ) ) ),
-                        nullptr )
-                );
-                auto&& name = SymTab::Mangler::mangle( mainDecl.get() );
-                // std::cerr << name << std::endl;
-                return std::move(name);
+        }
-        bool is_main(const std::string& name) {
-                static std::string mains[] = {
-                        mangle_main(),
-                        mangle_main_args()
-                };
-                for(const auto& m : mains) {
-                        if( name == m ) return true;
+                }
-                return false;
+        }
         void fixNames( std::list< Declaration* > & translationUnit ) {
                 PassVisitor<FixNames> fixer;
 …
                 fixDWT( functionDecl );
                 if(is_main( SymTab::Mangler::mangle(functionDecl, true, true) )) {
+                if ( FixMain::isMain( functionDecl ) ) {
                         int nargs = functionDecl->get_functionType()->get_parameters().size();
                         if( !(nargs == 0 || nargs == 2 || nargs == 3) ) {
 …
+                        }
                         functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );
-                        CodeGen::FixMain::registerMain( functionDecl );
+                }
+        }
 …
                 GuardAction( [this](){ scopeLevel--; } );
+        }
+/// Does work with the main function and scopeLevels.
+class FixNames_new : public ast::WithGuards {
+        int scopeLevel = 1;
+        bool shouldSetScopeLevel( const ast::DeclWithType * dwt ) {
+                return !dwt->name.empty() && dwt->linkage.is_mangled
+                        && dwt->scopeLevel != scopeLevel;
+        }
+public:
+        const ast::ObjectDecl *postvisit( const ast::ObjectDecl *objectDecl ) {
+                if ( shouldSetScopeLevel( objectDecl ) ) {
+                        return ast::mutate_field( objectDecl, &ast::ObjectDecl::scopeLevel, scopeLevel );
+                }
+                return objectDecl;
+        }
+        const ast::FunctionDecl *postvisit( const ast::FunctionDecl *functionDecl ) {
+                // This store is used to ensure a maximum of one call to mutate.
+                ast::FunctionDecl * mutDecl = nullptr;
+                if ( shouldSetScopeLevel( functionDecl ) ) {
+                        mutDecl = ast::mutate( functionDecl );
+                        mutDecl->scopeLevel = scopeLevel;
+                }
+                if ( FixMain::isMain( functionDecl ) ) {
+                        if ( !mutDecl ) { mutDecl = ast::mutate( functionDecl ); }
+                        int nargs = mutDecl->params.size();
+                        if ( 0 != nargs && 2 != nargs && 3 != nargs ) {
+                                SemanticError( functionDecl, "Main expected to have 0, 2 or 3 arguments\n" );
+                        }
+                        ast::chain_mutate( mutDecl->stmts )->kids.push_back(
+                                new ast::ReturnStmt(
+                                        mutDecl->location,
+                                        ast::ConstantExpr::from_int( mutDecl->location, 0 )
+                                )
+                        );
+                }
+                return mutDecl ? mutDecl : functionDecl;
+        }
+        void previsit( const ast::CompoundStmt * ) {
+                GuardValue( scopeLevel ) += 1;
+        }
+};
+void fixNames( ast::TranslationUnit & translationUnit ) {
+        ast::Pass<FixNames_new>::run( translationUnit );
+}
 } // namespace CodeGen

src/CodeGen/FixNames.h

-                      r94647b0
+                      r7770cc8
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Jul 21 22:17:33 2017
 // Update Count     : 3
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct 26 13:47:00 2021
+// Update Count     : 4
 //
 …
 class Declaration;
+namespace ast {
+        struct TranslationUnit;
+}
 namespace CodeGen {
         /// mangles object and function names
         void fixNames( std::list< Declaration* > & translationUnit );
+        void fixNames( ast::TranslationUnit & translationUnit );
 } // namespace CodeGen

src/CodeTools/DeclStats.cc

-                      r94647b0
+                      r7770cc8
                 /// number of counting bins for linkages
                 static const unsigned n_named_specs = 8;
+                /// map from total number of specs to bins
+                static const unsigned ind_for_linkage[16];
+                /// Mapping function from linkage to bin.
+                static unsigned linkage_index( LinkageSpec::Spec spec ) {
+                        switch ( spec ) {
+                        case LinkageSpec::Intrinsic:  return 0;
+                        case LinkageSpec::C:          return 1;
+                        case LinkageSpec::Cforall:    return 2;
+                        case LinkageSpec::AutoGen:    return 3;
+                        case LinkageSpec::Compiler:   return 4;
+                        case LinkageSpec::BuiltinCFA: return 5;
+                        case LinkageSpec::BuiltinC:   return 6;
+                        default:                      return 7;
+                        }
+                }
                 Stats for_linkage[n_named_specs];            ///< Stores separate stats per linkage
 …
                         const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName();
                         if ( seen_names.insert( mangleName ).second ) {
                                 Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ];
+                                Stats& stats = for_linkage[ linkage_index( decl->linkage ) ];
                                 ++stats.n_decls;
 …
         };
-        const unsigned DeclStats::ind_for_linkage[]
-                = { 7, 7, 2, 1,   7, 7, 7, 3,   4, 7, 6, 5,   7, 7, 7, 0 };
         void printDeclStats( std::list< Declaration * > &translationUnit ) {
                 PassVisitor<DeclStats> stats;

src/Common/module.mk

-                      r94647b0
+                      r7770cc8
       Common/CompilerError.h \
       Common/Debug.h \
+      Common/DeclStats.hpp \
+      Common/DeclStats.cpp \
       Common/ErrorObjects.h \
       Common/Eval.cc \
 …
       Common/PassVisitor.proto.h \
       Common/PersistentMap.h \
+      Common/ResolvProtoDump.hpp \
+      Common/ResolvProtoDump.cpp \
       Common/ScopedMap.h \
       Common/SemanticError.cc \

src/Concurrency/Keywords.cc

r94647b0	r7770cc8
979	979	// If this is the destructor for a monitor it must be mutex
980	980	if(isDtor) {
	981	// This reflects MutexKeyword::validate, except does not produce an error.
981	982	Type* ty = decl->get_functionType()->get_parameters().front()->get_type();
982	983

src/ControlStruct/ExceptTranslate.cc

r94647b0	r7770cc8
5	5	// file "LICENCE" distributed with Cforall.
6	6	//
7		// Except~~Visitor.cc --~~
	7	// ExceptTranslate.cc -- Conversion of exception control flow structures.
8	8	//
9	9	// Author : Andrew Beach

src/ControlStruct/ExceptTranslate.h

-                      r94647b0
+                      r7770cc8
 // file "LICENCE" distributed with Cforall.
 //
 // ExceptTranslate.h --
+// ExceptTranslate.h -- Conversion of exception control flow structures.
 //
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus May 19 11:47:00 2020
 // Update Count     : 5
+// Last Modified On : Mon Nov  8 11:43:00 2020
+// Update Count     : 6
 //
 …
 class Declaration;
+namespace ast {
+        class TranslationUnit;
+}
 namespace ControlStruct {
         void translateThrows( std::list< Declaration *> & translationUnit );
+        void translateThrows( ast::TranslationUnit & transUnit );
         /* Replaces all throw & throwResume statements with function calls.
          * These still need to be resolved, so call this before the reslover.

src/ControlStruct/LabelGenerator.cc

-                      r94647b0
+                      r7770cc8
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Mar 11 22:23:20 2019
 // Update Count     : 15
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Nov  8 10:18:00 2021
+// Update Count     : 17
 //
 …
 #include "LabelGenerator.h"
+#include "AST/Attribute.hpp"
+#include "AST/Label.hpp"
+#include "AST/Stmt.hpp"
 #include "SynTree/Attribute.h"  // for Attribute
 #include "SynTree/Label.h"      // for Label, operator<<
 …
 namespace ControlStruct {
+        LabelGenerator * LabelGenerator::labelGenerator = 0;
+int LabelGenerator::current = 0;
+LabelGenerator * LabelGenerator::labelGenerator = nullptr;
         LabelGenerator * LabelGenerator::getGenerator() {
 …
                 return l;
+        }
+ast::Label LabelGenerator::newLabel(
+                const std::string & suffix, const ast::Stmt * stmt ) {
+        assert( stmt );
+        std::ostringstream os;
+        os << "__L" << current++ << "__" << suffix;
+        if ( stmt && !stmt->labels.empty() ) {
+                os << "_" << stmt->labels.front() << "__";
+        }
+        ast::Label ret_label( stmt->location, os.str() );
+        ret_label.attributes.push_back( new ast::Attribute( "unused" ) );
+        return ret_label;
+}
 } // namespace ControlStruct

src/ControlStruct/LabelGenerator.h

-                      r94647b0
+                      r7770cc8
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:20:14 2017
 // Update Count     : 6
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Nov  8 10:16:00 2021
+// Update Count     : 8
 //
 …
 class Statement;
+namespace ast {
+        class Stmt;
+        class Label;
+}
 namespace ControlStruct {
+        class LabelGenerator {
+          public:
+                static LabelGenerator *getGenerator();
+                Label newLabel(std::string suffix, Statement * stmt = nullptr);
+                void reset() { current = 0; }
+                void rewind() { current--; }
+          protected:
+                LabelGenerator(): current(0) {}
+          private:
+                int current;
+                static LabelGenerator *labelGenerator;
+        };
+class LabelGenerator {
+        static int current;
+        static LabelGenerator *labelGenerator;
+protected:
+        LabelGenerator() {}
+public:
+        static LabelGenerator *getGenerator();
+        static Label newLabel(std::string suffix, Statement * stmt = nullptr);
+        static ast::Label newLabel( const std::string&, const ast::Stmt * );
+        static void reset() { current = 0; }
+        static void rewind() { current--; }
+};
 } // namespace ControlStruct

src/ControlStruct/module.mk

-                      r94647b0
+                      r7770cc8
         ControlStruct/ExceptDecl.cc \
         ControlStruct/ExceptDecl.h \
+        ControlStruct/FixLabels.cpp \
+        ControlStruct/FixLabels.hpp \
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ForExprMutator.h \
 …
         ControlStruct/MLEMutator.cc \
         ControlStruct/MLEMutator.h \
+        ControlStruct/MultiLevelExit.cpp \
+        ControlStruct/MultiLevelExit.hpp \
         ControlStruct/Mutate.cc \
         ControlStruct/Mutate.h
+SRC += $(SRC_CONTROLSTRUCT) ControlStruct/ExceptTranslate.cc ControlStruct/ExceptTranslate.h
+SRC += $(SRC_CONTROLSTRUCT) \
+        ControlStruct/ExceptTranslateNew.cpp \
+        ControlStruct/ExceptTranslate.cc \
+        ControlStruct/ExceptTranslate.h
 SRCDEMANGLE += $(SRC_CONTROLSTRUCT)

src/InitTweak/FixInitNew.cpp

-                      r94647b0
+                      r7770cc8
                 // need to add __Destructor for _tmp_cp variables as well
+                assertf( ast::dtorStruct && ast::dtorStruct->members.size() == 2, "Destructor generation requires __Destructor definition." );
+                assertf( ast::dtorStruct, "Destructor generation requires __Destructor definition." );
+                assertf( ast::dtorStruct->members.size() == 2, "__Destructor definition does not have expected fields." );
                 assertf( ast::dtorStructDestroy, "Destructor generation requires __destroy_Destructor." );
 …
                                                         static UniqueName memberDtorNamer = { "__memberDtor" };
                                                         assertf( Validate::dtorStruct, "builtin __Destructor not found." );
                                                         assertf( Validate::dtorStructDestroy, "builtin __destroy_Destructor not found." );
+                                                        assertf( ast::dtorStruct, "builtin __Destructor not found." );
+                                                        assertf( ast::dtorStructDestroy, "builtin __destroy_Destructor not found." );
                                                         ast::Expr * thisExpr = new ast::CastExpr( new ast::AddressExpr( new ast::VariableExpr(loc, thisParam ) ), new ast::PointerType( new ast::VoidType(), ast::CV::Qualifiers() ) );

src/InitTweak/GenInit.cc

-                      r94647b0
+                      r7770cc8
 // Author           : Rob Schluntz
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:15:10 2019
 // Update Count     : 184
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Oct 25 13:53:00 2021
+// Update Count     : 186
 //
 #include "GenInit.h"
 …
 #include "AST/Decl.hpp"
 #include "AST/Init.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Node.hpp"
 #include "AST/Stmt.hpp"
 …
+        }
+namespace {
+#       warning Remove the _New suffix after the conversion is complete.
+        struct HoistArrayDimension_NoResolve_New final :
+                        public ast::WithDeclsToAdd<>, public ast::WithShortCircuiting,
+                        public ast::WithGuards, public ast::WithConstTranslationUnit,
+                        public ast::WithVisitorRef<HoistArrayDimension_NoResolve_New> {
+                void previsit( const ast::ObjectDecl * decl );
+                const ast::DeclWithType * postvisit( const ast::ObjectDecl * decl );
+                // Do not look for objects inside there declarations (and type).
+                void previsit( const ast::AggregateDecl * ) { visit_children = false; }
+                void previsit( const ast::NamedTypeDecl * ) { visit_children = false; }
+                void previsit( const ast::FunctionType * ) { visit_children = false; }
+                const ast::Type * hoist( const ast::Type * type );
+                ast::Storage::Classes storageClasses;
+        };
+        void HoistArrayDimension_NoResolve_New::previsit(
+                        const ast::ObjectDecl * decl ) {
+                GuardValue( storageClasses ) = decl->storage;
+        }
+        const ast::DeclWithType * HoistArrayDimension_NoResolve_New::postvisit(
+                        const ast::ObjectDecl * objectDecl ) {
+                return mutate_field( objectDecl, &ast::ObjectDecl::type,
+                                hoist( objectDecl->type ) );
+        }
+        const ast::Type * HoistArrayDimension_NoResolve_New::hoist(
+                        const ast::Type * type ) {
+                static UniqueName dimensionName( "_array_dim" );
+                if ( !isInFunction() || storageClasses.is_static ) {
+                        return type;
+                }
+                if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        if ( nullptr == arrayType->dimension ) {
+                                return type;
+                        }
+                        if ( !Tuples::maybeImpure( arrayType->dimension ) ) {
+                                return type;
+                        }
+                        ast::ptr<ast::Type> dimType = transUnit().global.sizeType;
+                        assert( dimType );
+                        add_qualifiers( dimType, ast::CV::Qualifiers( ast::CV::Const ) );
+                        ast::ObjectDecl * arrayDimension = new ast::ObjectDecl(
+                                arrayType->dimension->location,
+                                dimensionName.newName(),
+                                dimType,
+                                new ast::SingleInit(
+                                        arrayType->dimension->location,
+                                        arrayType->dimension
+                                )
+                        );
+                        ast::ArrayType * mutType = ast::mutate( arrayType );
+                        mutType->dimension = new ast::VariableExpr(
+                                        arrayDimension->location, arrayDimension );
+                        declsToAddBefore.push_back( arrayDimension );
+                        mutType->base = hoist( mutType->base );
+                        return mutType;
+                }
+                return type;
+        }
+        struct ReturnFixer_New final :
+                        public ast::WithStmtsToAdd<>, ast::WithGuards {
+                void previsit( const ast::FunctionDecl * decl );
+                const ast::ReturnStmt * previsit( const ast::ReturnStmt * stmt );
+        private:
+                const ast::FunctionDecl * funcDecl = nullptr;
+        };
+        void ReturnFixer_New::previsit( const ast::FunctionDecl * decl ) {
+                GuardValue( funcDecl ) = decl;
+        }
+        const ast::ReturnStmt * ReturnFixer_New::previsit(
+                        const ast::ReturnStmt * stmt ) {
+                auto & returns = funcDecl->returns;
+                assert( returns.size() < 2 );
+                // Hands off if the function returns a reference.
+                // Don't allocate a temporary if the address is returned.
+                if ( stmt->expr && 1 == returns.size() ) {
+                        ast::ptr<ast::DeclWithType> retDecl = returns.front();
+                        if ( isConstructable( retDecl->get_type() ) ) {
+                                // Explicitly construct the return value using the return
+                                // expression and the retVal object.
+                                assertf( "" != retDecl->name,
+                                        "Function %s has unnamed return value.\n",
+                                        funcDecl->name.c_str() );
+                                auto retVal = retDecl.strict_as<ast::ObjectDecl>();
+                                if ( auto varExpr = stmt->expr.as<ast::VariableExpr>() ) {
+                                        // Check if the return statement is already set up.
+                                        if ( varExpr->var == retVal ) return stmt;
+                                }
+                                ast::ptr<ast::Stmt> ctorStmt = genCtorDtor(
+                                        retVal->location, "?{}", retVal, stmt->expr );
+                                assertf( ctorStmt,
+                                        "ReturnFixer: genCtorDtor returned nllptr: %s / %s",
+                                        toString( retVal ).c_str(),
+                                        toString( stmt->expr ).c_str() );
+                                        stmtsToAddBefore.push_back( ctorStmt );
+                                // Return the retVal object.
+                                ast::ReturnStmt * mutStmt = ast::mutate( stmt );
+                                mutStmt->expr = new ast::VariableExpr(
+                                        stmt->location, retDecl );
+                                return mutStmt;
+                        }
+                }
+                return stmt;
+        }
+} // namespace
+        void genInit( ast::TranslationUnit & transUnit ) {
+                ast::Pass<HoistArrayDimension_NoResolve_New>::run( transUnit );
+                ast::Pass<ReturnFixer_New>::run( transUnit );
+        }
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<CtorDtor> ctordtor;

src/InitTweak/GenInit.h

-                      r94647b0
+                      r7770cc8
 // Author           : Rodolfo G. Esteves
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:31:19 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Oct 22 16:08:00 2021
+// Update Count     : 6
 //
 …
         /// Adds return value temporaries and wraps Initializers in ConstructorInit nodes
         void genInit( std::list< Declaration * > & translationUnit );
+        void genInit( ast::TranslationUnit & translationUnit );
         /// Converts return statements into copy constructor calls on the hidden return variable

src/InitTweak/InitTweak.cc

-                      r94647b0
+                      r7770cc8
 // Author           : Rob Schluntz
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Jun 16 20:57:22 2021
 // Update Count     : 18
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Nov 19 19:22:00 2021
+// Update Count     : 19
 //
 …
+        }
+        const ast::Type * getTypeofThis( const ast::FunctionType * ftype ) {
+                assertf( ftype, "getTypeofThis: nullptr ftype" );
+                const std::vector<ast::ptr<ast::Type>> & params = ftype->params;
+                assertf( !params.empty(), "getTypeofThis: ftype with 0 parameters: %s",
+                                toString( ftype ).c_str() );
+                const ast::ReferenceType * refType =
+                        params.front().strict_as<ast::ReferenceType>();
+                return refType->base;
+        }
         ObjectDecl * getParamThis( FunctionType * ftype ) {
                 assertf( ftype, "getParamThis: nullptr ftype" );

src/InitTweak/InitTweak.h

-                      r94647b0
+                      r7770cc8
 // Created On       : Fri May 13 11:26:36 2016
 // Last Modified By : Andrew Beach
 // Last Modified On : Fri Jul 19 14:18:00 2019
 // Update Count     : 6
+// Last Modified On : Fri Nov 19 14:18:00 2021
+// Update Count     : 7
 //
 …
         /// returns the base type of the first parameter to a constructor/destructor/assignment function
         Type * getTypeofThis( FunctionType * ftype );
+        const ast::Type * getTypeofThis( const ast::FunctionType * ftype );
         /// returns the first parameter of a constructor/destructor/assignment function

src/Parser/parser.yy

-                      r94647b0
+                      r7770cc8
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Sep 11 08:20:44 2021
 // Update Count     : 5040
+// Last Modified On : Fri Oct 15 09:20:17 2021
+// Update Count     : 5163
 //
 …
 // from ANSI90 to ANSI11 C are marked with the comment "C99/C11".
 // This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions All of the
+// This grammar also has two levels of extensions. The first extensions cover most of the GCC C extensions. All of the
 // syntactic extensions for GCC C are marked with the comment "GCC". The second extensions are for Cforall (CFA), which
 // fixes several of C's outstanding problems and extends C with many modern language concepts. All of the syntactic
 …
         // 2. String encodings are transformed into canonical form (one encoding at start) so the encoding can be found
         //    without searching the string, e.g.: "abc" L"def" L"ghi" => L"abc" "def" "ghi". Multiple encodings must match,
         //    i.e., u"a" U"b" L"c" is disallowed.
+        //    e.g., u"a" U"b" L"c" is disallowed.
         if ( from[0] != '"' ) {                                                         // encoding ?
 …
 %token ATassign                                                                                 // @=
+%type<tok> identifier
+%type<tok> identifier_or_type_name  attr_name
+%type<tok> identifier                                   identifier_at                           identifier_or_type_name         attr_name
 %type<tok> quasi_keyword
 %type<constant> string_literal
 …
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list_opt  argument_expression                     default_initializer_opt
+%type<en> argument_expression_list_opt  argument_expression_list        argument_expression                     default_initializer_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
 …
         IDENTIFIER
         | quasi_keyword
+        ;
+identifier_at:
+        identifier
         | '@'                                                                                           // CFA
                 { Token tok = { new string( DeclarationNode::anonymous.newName() ), yylval.tok.loc }; $$ = tok; }
 …
         // empty
                 { $$ = nullptr; }
+        | argument_expression
+        | argument_expression_list
+        ;
+argument_expression_list:
+        argument_expression
         | argument_expression_list_opt ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
 …
         | FLOATINGconstant fraction_constants_opt
                 { $$ = new ExpressionNode( build_field_name_fraction_constants( build_field_name_FLOATINGconstant( *$1 ), $2 ) ); }
         | identifier fraction_constants_opt
+        | identifier_at fraction_constants_opt                          // CFA, allow anonymous fields
+                {
                         $$ = new ExpressionNode( build_field_name_fraction_constants( build_varref( $1 ), $2 ) );
 …
         comma_expression_opt ';'
                 { $$ = new StatementNode( build_expr( $1 ) ); }
+        | MUTEX '(' ')' comma_expression ';'
+                { $$ = new StatementNode( build_mutex( nullptr, new StatementNode( build_expr( $4 ) ) ) ); }
+                // { SemanticError( yylloc, "Mutex expression is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
 iteration_statement:
+        WHILE '(' push if_control_expression ')' statement pop
+                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
+        | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
+        WHILE '(' ')' statement                                                         // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ';'
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement         %prec THEN
+                { $$ = new StatementNode( build_while( $3, maybe_build_compound( $5 ) ) ); }
+        | WHILE '(' if_control_expression ')' statement ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
+        | FOR '(' push for_control_expression_list ')' statement pop
+                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ';'       %prec THEN
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
+        | DO statement WHILE '(' comma_expression ')' ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+        | FOR '(' for_control_expression_list ')' statement     %prec THEN
+                { $$ = new StatementNode( build_for( $3, maybe_build_compound( $5 ) ) ); }
+        | FOR '(' for_control_expression_list ')' statement ELSE statement // CFA
+                { SemanticError( yylloc, "Loop default block is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
 with_statement:
         WITH '(' tuple_expression_list ')' statement
+                {
+                        $$ = new StatementNode( build_with( $3, $5 ) );
+                }
+                { $$ = new StatementNode( build_with( $3, $5 ) ); }
+        ;
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
         MUTEX '(' argument_expression_list_opt ')' statement
+        MUTEX '(' argument_expression_list ')' statement
                 { $$ = new StatementNode( build_mutex( $3, $5 ) ); }
+        ;
 …
 designation:
         designator_list ':'                                                                     // C99, CFA uses ":" instead of "="
         | identifier ':'                                                                        // GCC, field name
+        | identifier_at ':'                                                                     // GCC, field name
                 { $$ = new ExpressionNode( build_varref( $1 ) ); }
+        ;
 …
 designator:
         '.' identifier                                                                          // C99, field name
+        '.' identifier_at                                                                       // C99, field name
                 { $$ = new ExpressionNode( build_varref( $2 ) ); }
         | '[' push assignment_expression pop ']'                        // C99, single array element
 …
 paren_identifier:
         identifier
+        identifier_at
                 { $$ = DeclarationNode::newName( $1 ); }
         | '(' paren_identifier ')'                                                      // redundant parenthesis

src/ResolvExpr/module.mk

-                      r94647b0
+                      r7770cc8
       ResolvExpr/WidenMode.h
+SRC += $(SRC_RESOLVEXPR) \
+        ResolvExpr/AlternativePrinter.cc \
+        ResolvExpr/AlternativePrinter.h \
+        ResolvExpr/CandidatePrinter.cpp \
+        ResolvExpr/CandidatePrinter.hpp
-SRC += $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc ResolvExpr/AlternativePrinter.h
 SRCDEMANGLE += $(SRC_RESOLVEXPR)

src/SymTab/Validate.cc

-                      r94647b0
+                      r7770cc8
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:43:34 2019
 // Update Count     : 363
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Nov 12 11:00:00 2021
+// Update Count     : 364
 //
 …
         };
         void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
+        void validate_A( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<EnumAndPointerDecay_old> epc;
-                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
-                PassVisitor<ResolveEnumInitializers> rei( nullptr );
-                PassVisitor<ForallPointerDecay_old> fpd;
-                PassVisitor<CompoundLiteral> compoundliteral;
-                PassVisitor<ValidateGenericParameters> genericParams;
-                PassVisitor<LabelAddressFixer> labelAddrFixer;
                 PassVisitor<HoistTypeDecls> hoistDecls;
-                PassVisitor<FixQualifiedTypes> fixQual;
+                {
                         Stats::Heap::newPass("validate-A");
 …
                         acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling
+                }
+        }
+        void validate_B( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
+                PassVisitor<FixQualifiedTypes> fixQual;
+                {
                         Stats::Heap::newPass("validate-B");
 …
                         EliminateTypedef::eliminateTypedef( translationUnit );
+                }
+        }
+        void validate_C( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<ValidateGenericParameters> genericParams;
+                PassVisitor<ResolveEnumInitializers> rei( nullptr );
+                {
                         Stats::Heap::newPass("validate-C");
 …
                         });
+                }
+        }
+        void validate_D( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<ForallPointerDecay_old> fpd;
+                {
                         Stats::Heap::newPass("validate-D");
 …
                         });
+                }
+        }
+        void validate_E( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<CompoundLiteral> compoundliteral;
+                {
                         Stats::Heap::newPass("validate-E");
 …
+                        }
+                }
+        }
+        void validate_F( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<LabelAddressFixer> labelAddrFixer;
+                {
                         Stats::Heap::newPass("validate-F");
 …
+                        }
+                }
+        }
+        void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
+                validate_A( translationUnit );
+                validate_B( translationUnit );
+                validate_C( translationUnit );
+                validate_D( translationUnit );
+                validate_E( translationUnit );
+                validate_F( translationUnit );
+        }

src/SymTab/Validate.h

-                      r94647b0
+                      r7770cc8
         void validateType( Type *type, const Indexer *indexer );
+        // Sub-passes of validate.
+        void validate_A( std::list< Declaration * > &translationUnit );
+        void validate_B( std::list< Declaration * > &translationUnit );
+        void validate_C( std::list< Declaration * > &translationUnit );
+        void validate_D( std::list< Declaration * > &translationUnit );
+        void validate_E( std::list< Declaration * > &translationUnit );
+        void validate_F( std::list< Declaration * > &translationUnit );
         const ast::Type * validateType(
                 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab );

src/Tuples/TupleExpansionNew.cpp

-                      r94647b0
+                      r7770cc8
                 void previsit( const ast::UntypedMemberExpr * ) { visit_children = false; }
         const ast::Expr * postvisit( const ast::UntypedMemberExpr * memberExpr );
+        };
+        struct UniqueExprExpander final : public ast::WithDeclsToAdd<> {
+                const ast::Expr * postvisit( const ast::UniqueExpr * unqExpr );
+                std::map< int, ast::ptr<ast::Expr> > decls; // not vector, because order added may not be increasing order
         };
 } // namespace
 …
+        }
 } // namespace
+void expandUniqueExpr( ast::TranslationUnit & translationUnit ) {
+        ast::Pass< UniqueExprExpander >::run( translationUnit );
+}
+namespace {
+        const ast::Expr * UniqueExprExpander::postvisit( const ast::UniqueExpr * unqExpr ) {
+                const CodeLocation loc = unqExpr->location;
+                const int id = unqExpr->id;
+                // on first time visiting a unique expr with a particular ID, generate the expression that replaces all UniqueExprs with that ID,
+                // and lookup on subsequent hits. This ensures that all unique exprs with the same ID reference the same variable.
+                if ( ! decls.count( id ) ) {
+                        ast::ptr< ast::Expr > assignUnq;
+                        const ast::VariableExpr * var = unqExpr->var;
+                        if ( unqExpr->object ) {
+                                // an object was generated to represent this unique expression -- it should be added to the list of declarations now
+                                declsToAddBefore.push_back( unqExpr->object.as< ast::Decl >() );
+                                // deep copy required due to unresolved issues with UniqueExpr
+                                assignUnq = ast::UntypedExpr::createAssign( loc, var, unqExpr->expr );
+                        } else {
+                                const auto commaExpr = unqExpr->expr.strict_as< ast::CommaExpr >();
+                                assignUnq = commaExpr->arg1;
+                        }
+                        auto finished = new ast::ObjectDecl( loc, toString( "_unq", id, "_finished_" ), new ast::BasicType( ast::BasicType::Kind::Bool ),
+                                new ast::SingleInit( loc, ast::ConstantExpr::from_int( loc, 0 ) ), {}, ast::Linkage::Cforall );
+                        declsToAddBefore.push_back( finished );
+                        // (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
+                        // This pattern ensures that each unique expression is evaluated once, regardless of evaluation order of the generated C code.
+                        auto assignFinished = ast::UntypedExpr::createAssign( loc, new ast::VariableExpr( loc, finished ),
+                                ast::ConstantExpr::from_int( loc, 1 ) );
+                        auto condExpr = new ast::ConditionalExpr( loc, new ast::VariableExpr( loc, finished ), var,
+                                new ast::CommaExpr( loc, new ast::CommaExpr( loc, assignUnq, assignFinished ), var ) );
+                        condExpr->result = var->result;
+                        condExpr->env = unqExpr->env;
+                        decls[id] = condExpr;
+                }
+                //delete unqExpr;
+                return ast::deepCopy(decls[id].get());
+        }
+} // namespace
 } // namespace Tuples

src/Tuples/Tuples.h

r94647b0	r7770cc8
46	46	/// replaces UniqueExprs with a temporary variable and one call
47	47	void expandUniqueExpr( std::list< Declaration * > & translationUnit );
	48	void expandUniqueExpr( ast::TranslationUnit & translationUnit );
48	49
49	50	/// returns VoidType if any of the expressions have Voidtype, otherwise TupleType of the Expression result types

src/Validate/FindSpecialDecls.h

-                      r94647b0
+                      r7770cc8
 // Author           : Rob Schluntz
 // Created On       : Thu Aug 30 09:49:02 2018
 // Last Modified By : Rob Schluntz
 // Last Modified On : Thu Aug 30 09:51:12 2018
 // Update Count     : 2
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Nov 10 15:16:00 2021
+// Update Count     : 3
 //
 …
 class StructDecl;
 class Type;
+namespace ast {
+        class TranslationUnit;
+}
 namespace Validate {
 …
         /// find and remember some of the special declarations that are useful for generating code, so that they do not have to be discovered multiple times.
         void findSpecialDecls( std::list< Declaration * > & translationUnit );
+/// find and remember some of the special declarations that are useful for
+/// generating code, so that they do not have to be discovered multiple times.
+void findGlobalDecls( ast::TranslationUnit & translationUnit );
 } // namespace Validate

src/Validate/module.mk

-                      r94647b0
+                      r7770cc8
 ###############################################################################
+SRC += Validate/HandleAttributes.cc Validate/HandleAttributes.h Validate/FindSpecialDecls.cc Validate/FindSpecialDecls.h
+SRCDEMANGLE += Validate/HandleAttributes.cc Validate/HandleAttributes.h Validate/FindSpecialDecls.cc Validate/FindSpecialDecls.h
+SRC_VALIDATE = \
+        Validate/HandleAttributes.cc \
+        Validate/HandleAttributes.h \
+        Validate/InitializerLength.cpp \
+        Validate/InitializerLength.hpp \
+        Validate/LabelAddressFixer.cpp \
+        Validate/LabelAddressFixer.hpp \
+        Validate/FindSpecialDeclsNew.cpp \
+        Validate/FindSpecialDecls.cc \
+        Validate/FindSpecialDecls.h
+SRC += $(SRC_VALIDATE)
+SRCDEMANGLE += $(SRC_VALIDATE)

src/main.cc

-                      r94647b0
+                      r7770cc8
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Henry Xue
 // Last Modified On : Mon Aug 23 15:42:08 2021
 // Update Count     : 650
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Nov 12 11:06:00 2021
+// Update Count     : 658
 //
 …
 #include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Common/CompilerError.h"           // for CompilerError
+#include "Common/DeclStats.hpp"             // for printDeclStats
+#include "Common/ResolvProtoDump.hpp"       // for dumpAsResolverProto
 #include "Common/Stats.h"
 #include "Common/PassVisitor.h"
 …
 #include "ControlStruct/ExceptDecl.h"       // for translateExcept
 #include "ControlStruct/ExceptTranslate.h"  // for translateEHM
+#include "ControlStruct/FixLabels.hpp"      // for fixLabels
 #include "ControlStruct/Mutate.h"           // for mutate
 #include "GenPoly/Box.h"                    // for box
 …
 #include "Parser/TypedefTable.h"            // for TypedefTable
 #include "ResolvExpr/AlternativePrinter.h"  // for AlternativePrinter
+#include "ResolvExpr/CandidatePrinter.hpp"  // for printCandidates
 #include "ResolvExpr/Resolver.h"            // for resolve
 #include "SymTab/Validate.h"                // for validate
 …
 #include "SynTree/Visitor.h"                // for acceptAll
 #include "Tuples/Tuples.h"                  // for expandMemberTuples, expan...
+#include "Validate/FindSpecialDecls.h"      // for findGlobalDecls
+#include "Validate/InitializerLength.hpp"   // for setLengthFromInitializer
+#include "Validate/LabelAddressFixer.hpp"   // for fixLabelAddresses
 #include "Virtual/ExpandCasts.h"            // for expandCasts
 …
                 // add the assignment statement after the initialization of a type parameter
+                PASS( "Validate", SymTab::validate( translationUnit, symtabp ) );
+                if ( symtabp ) {
+                        deleteAll( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                if ( expraltp ) {
+                        PassVisitor<ResolvExpr::AlternativePrinter> printer( cout );
+                        acceptAll( translationUnit, printer );
+                        return EXIT_SUCCESS;
+                } // if
+                if ( validp ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
+                PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
+                PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
+                if ( libcfap ) {
+                        // generate the bodies of cfa library functions
+                        LibCfa::makeLibCfa( translationUnit );
+                } // if
+                if ( declstatsp ) {
+                        CodeTools::printDeclStats( translationUnit );
+                        deleteAll( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                if ( bresolvep ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                PASS( "Validate-A", SymTab::validate_A( translationUnit ) );
+                PASS( "Validate-B", SymTab::validate_B( translationUnit ) );
+                PASS( "Validate-C", SymTab::validate_C( translationUnit ) );
+                PASS( "Validate-D", SymTab::validate_D( translationUnit ) );
+                PASS( "Validate-E", SymTab::validate_E( translationUnit ) );
                 CodeTools::fillLocations( translationUnit );
-                if ( resolvprotop ) {
-                        CodeTools::dumpAsResolvProto( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
                 if( useNewAST ) {
 …
                         auto transUnit = convert( move( translationUnit ) );
+                        forceFillCodeLocations( transUnit );
+                        PASS( "Set Length From Initializer", Validate::setLengthFromInitializer( transUnit ) );
+                        PASS( "Find Global Decls", Validate::findGlobalDecls( transUnit ) );
+                        PASS( "Fix Label Address", Validate::fixLabelAddresses( transUnit ) );
+                        if ( symtabp ) {
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( expraltp ) {
+                                ResolvExpr::printCandidates( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( validp ) {
+                                dump( move( transUnit ) );
+                                return EXIT_SUCCESS;
+                        } // if
+                        PASS( "Translate Throws", ControlStruct::translateThrows( transUnit ) );
+                        PASS( "Fix Labels", ControlStruct::fixLabels( transUnit ) );
+                        PASS( "Fix Names", CodeGen::fixNames( transUnit ) );
+                        PASS( "Gen Init", InitTweak::genInit( transUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( transUnit ) );
+                        if ( libcfap ) {
+                                // Generate the bodies of cfa library functions.
+                                LibCfa::makeLibCfa( transUnit );
+                        } // if
+                        if ( declstatsp ) {
+                                printDeclStats( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( bresolvep ) {
+                                dump( move( transUnit ) );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( resolvprotop ) {
+                                dumpAsResolverProto( transUnit );
+                                return EXIT_SUCCESS;
+                        } // if
                         PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
                         if ( exprp ) {
 …
                         PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
+                        // fix ObjectDecl - replaces ConstructorInit nodes
+                        if ( ctorinitp ) {
+                                dump( move( transUnit ) );
+                                return EXIT_SUCCESS;
+                        } // if
+                        // Currently not working due to unresolved issues with UniqueExpr
+                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( transUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                         translationUnit = convert( move( transUnit ) );
                 } else {
+                        PASS( "Validate-F", SymTab::validate_F( translationUnit ) );
+                        if ( symtabp ) {
+                                deleteAll( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( expraltp ) {
+                                PassVisitor<ResolvExpr::AlternativePrinter> printer( cout );
+                                acceptAll( translationUnit, printer );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( validp ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
+                        PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
+                        PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
+                        PASS( "Gen Init", InitTweak::genInit( translationUnit ) );
                         PASS( "Expand Member Tuples" , Tuples::expandMemberTuples( translationUnit ) );
+                        if ( libcfap ) {
+                                // Generate the bodies of cfa library functions.
+                                LibCfa::makeLibCfa( translationUnit );
+                        } // if
+                        if ( declstatsp ) {
+                                CodeTools::printDeclStats( translationUnit );
+                                deleteAll( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        if ( bresolvep ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        CodeTools::fillLocations( translationUnit );
+                        if ( resolvprotop ) {
+                                CodeTools::dumpAsResolvProto( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
                         PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
 …
                         PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
+                        // fix ObjectDecl - replaces ConstructorInit nodes
+                        if ( ctorinitp ) {
+                                dump ( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
+                }
-                // fix ObjectDecl - replaces ConstructorInit nodes
-                if ( ctorinitp ) {
-                        dump ( translationUnit );
-                        return EXIT_SUCCESS;
-                } // if
-                PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                 PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
 …
                 PASS( "Code Gen", CodeGen::generate( translationUnit, *output, ! genproto, prettycodegenp, true, linemarks ) );
+                CodeGen::FixMain::fix( *output, (PreludeDirector + "/bootloader.c").c_str() );
+                CodeGen::FixMain::fix( translationUnit, *output,
+                                (PreludeDirector + "/bootloader.c").c_str() );
                 if ( output != &cout ) {
                         delete output;

tests/.expect/declarationSpecifier.x64.txt

-                      r94647b0
+                      r7770cc8
 char **_X13cfa_args_argvPPc_1;
 char **_X13cfa_args_envpPPc_1;
 signed int _X17cfa_main_returnedi_1 = ((signed int )0);
+__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
 signed int main(signed int _X4argci_1, char **_X4argvPPc_1, char **_X4envpPPc_1){
     __attribute__ ((unused)) signed int _X12_retval_maini_1;
 …
     signed int _tmp_cp_ret6;
     signed int _X3reti_2 = (((void)(_tmp_cp_ret6=invoke_main(_X4argci_1, _X4argvPPc_1, _X4envpPPc_1))) , _tmp_cp_ret6);
+    {
+        ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+    if ( ((&_X17cfa_main_returnedi_1)!=((signed int *)0)) ) {
+        {
+            ((void)(_X17cfa_main_returnedi_1=((signed int )1)));
+        }
+    }

tests/.expect/declarationSpecifier.x86.txt

r94647b0	r7770cc8
1132	1132	char **_X13cfa_args_argvPPc_1;
1133	1133	char **_X13cfa_args_envpPPc_1;
1134		~~signed int _X17cfa_main_returnedi_1 = ((signed int )0)~~;
	1134	__attribute__ ((weak)) extern signed int _X17cfa_main_returnedi_1;
1135	1135	signed int main(signed int _X4argci_1, char _X4argvPPc_1, char _X4envpPPc_1){

Context Navigation

Legend: