Changeset 3a32b3a

Timestamp:

Jul 10, 2020, 11:42:41 AM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

20ab637, 2fc94ced, fb98462

Parents:

732b406 (diff), 49cad912 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Files:

• libcfa/src/exception.c (modified) (1 diff)
• libcfa/src/iostream.cfa (modified) (9 diffs)
• libcfa/src/iostream.hfa (modified) (3 diffs)
• src/GenPoly/Specialize.cc (modified) (4 diffs)
• src/Parser/ParseNode.h (modified) (2 diffs)
• tests/.expect/global-monomorph.txt (added)
• tests/.expect/manipulatorsOutput3.x64.txt (added)
• tests/bugs/.expect/10.txt (added)
• tests/bugs/.expect/194.txt (added)
• tests/bugs/.expect/20.txt (added)
• tests/bugs/.expect/44.txt (added)
• tests/bugs/.expect/46.txt (added)
• tests/bugs/.expect/5.txt (added)
• tests/bugs/.expect/66.txt (added)
• tests/bugs/.expect/91.txt (added)
• tests/bugs/.expect/92.txt (added)
• tests/bugs/.expect/95.txt (added)
• tests/bugs/10.cfa (added)
• tests/bugs/104.cfa (added)
• tests/bugs/194.cfa (added)
• tests/bugs/20.cfa (added)
• tests/bugs/44.cfa (added)
• tests/bugs/46.cfa (added)
• tests/bugs/5.cfa (added)
• tests/bugs/66.cfa (added)
• tests/bugs/7.cfa (added)
• tests/bugs/91.cfa (added)
• tests/bugs/92.cfa (added)
• tests/bugs/95.cfa (added)
• tests/copyfile.cfa (modified) (2 diffs)
• tests/exceptions/.expect/defaults.txt (modified) (1 diff)
• tests/exceptions/defaults.cfa (modified) (2 diffs)
• tests/global-monomorph.cfa (added)
• tests/manipulatorsOutput3.cfa (modified) (3 diffs)
• tests/pybin/test_run.py (modified) (1 diff)
• tests/pybin/tools.py (modified) (1 diff)
• tests/test.py (modified) (1 diff)

libcfa/src/exception.c

@@ -85 +85 @@
         __cfadbg_print_safe(exception, "Throwing resumption exception\n");
 
-        __attribute__((cleanup(reset_top_resume)))
-        struct __cfaehm_try_resume_node * original_head = context->top_resume;
-        struct __cfaehm_try_resume_node * current = context->top_resume;
-
-        for ( ; current ; current = current->next) {
-                context->top_resume = current->next;
-                if (current->handler(except)) {
-                        return;
+        {
+                __attribute__((cleanup(reset_top_resume)))
+                struct __cfaehm_try_resume_node * original_head = context->top_resume;
+                struct __cfaehm_try_resume_node * current = context->top_resume;
+
+                for ( ; current ; current = current->next) {
+                        context->top_resume = current->next;
+                        if (current->handler(except)) {
+                                return;
+                        }
                 }
-        }
+        } // End the search and return to the top of the stack.
 
         // No handler found, fall back to the default operation.

libcfa/src/iostream.cfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 19 16:15:34 2020
-// Update Count     : 1019
+// Last Modified On : Mon Jul  6 08:49:48 2020
+// Update Count     : 1064
 //
 
@@ -30 +30 @@
 } // extern "C"
 
-#include <bitmanip.hfa>                                                                 // fms
+#include <bitmanip.hfa>                                                                 // high1
 
 
@@ -168 +168 @@
 
         static void base10_128( ostype & os, unsigned int128 val ) {
-                if ( val > UINT64_MAX ) {
+                if ( val > P10_UINT64 ) {
                         base10_128( os, val / P10_UINT64 );                     // recursive
                         fmt( os, "%.19lu", (uint64_t)(val % P10_UINT64) );
@@ -455 +455 @@
 
 // Default prefix for non-decimal prints is 0b, 0, 0x.
-#define IntegralFMTImpl( T, CODE, IFMTNP, IFMTP ) \
+#define IntegralFMTImpl( T, IFMTNP, IFMTP ) \
 forall( dtype ostype | ostream( ostype ) ) { \
         ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
@@ -506 +506 @@
                         if ( f.flags.left && spaces > 0 ) fmt( os, "%*s", spaces, " " ); \
                         return os; \
-                } /* if  */ \
+                } /* if */ \
 \
                 char fmtstr[sizeof(IFMTP)];                                             /* sizeof includes '\0' */ \
@@ -516 +516 @@
                 if ( ! f.flags.nobsdp ) { fmtstr[star] = '#'; star -= 1; } \
                 if ( f.flags.left ) { fmtstr[star] = '-'; star -= 1; } \
-                if ( f.flags.sign && f.base == CODE ) { fmtstr[star] = '+'; star -= 1; } \
+                if ( f.flags.sign ) { fmtstr[star] = '+'; star -= 1; } \
                 if ( f.flags.pad0 && ! f.flags.pc ) { fmtstr[star] = '0'; star -= 1; } \
                 fmtstr[star] = '%'; \
@@ -522 +522 @@
                 if ( ! f.flags.pc ) {                                                   /* no precision */ \
                         fmtstr[sizeof(IFMTNP)-2] = f.base;                      /* sizeof includes '\0' */ \
-                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
+                        /* printf( "%s %c\n", &fmtstr[star], f.base ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.val ); \
                 } else {                                                                                /* precision */ \
                         fmtstr[sizeof(IFMTP)-2] = f.base;                       /* sizeof includes '\0' */ \
-                        /* printf( "%s %c %c\n", &fmtstr[star], f.base, CODE ); */ \
+                        /* printf( "%s %c\n", &fmtstr[star], f.base ); */ \
                         fmt( os, &fmtstr[star], f.wd, f.pc, f.val ); \
                 } /* if */ \
@@ -534 +534 @@
 } // distribution
 
-IntegralFMTImpl( signed char, 'd', "%    *hh ", "%    *.*hh " )
-IntegralFMTImpl( unsigned char, 'u', "%    *hh ", "%    *.*hh " )
-IntegralFMTImpl( signed short int, 'd', "%    *h ", "%    *.*h " )
-IntegralFMTImpl( unsigned short int, 'u', "%    *h ", "%    *.*h " )
-IntegralFMTImpl( signed int, 'd', "%    * ", "%    *.* " )
-IntegralFMTImpl( unsigned int, 'u', "%    * ", "%    *.* " )
-IntegralFMTImpl( signed long int, 'd', "%    *l ", "%    *.*l " )
-IntegralFMTImpl( unsigned long int, 'u', "%    *l ", "%    *.*l " )
-IntegralFMTImpl( signed long long int, 'd', "%    *ll ", "%    *.*ll " )
-IntegralFMTImpl( unsigned long long int, 'u', "%    *ll ", "%    *.*ll " )
-
-
+IntegralFMTImpl( signed char, "%    *hh ", "%    *.*hh " )
+IntegralFMTImpl( unsigned char, "%    *hh ", "%    *.*hh " )
+IntegralFMTImpl( signed short int, "%    *h ", "%    *.*h " )
+IntegralFMTImpl( unsigned short int, "%    *h ", "%    *.*h " )
+IntegralFMTImpl( signed int, "%    * ", "%    *.* " )
+IntegralFMTImpl( unsigned int, "%    * ", "%    *.* " )
+IntegralFMTImpl( signed long int, "%    *l ", "%    *.*l " )
+IntegralFMTImpl( unsigned long int, "%    *l ", "%    *.*l " )
+IntegralFMTImpl( signed long long int, "%    *ll ", "%    *.*ll " )
+IntegralFMTImpl( unsigned long long int, "%    *ll ", "%    *.*ll " )
+
+#if 0
 #if defined( __SIZEOF_INT128__ )
 // Default prefix for non-decimal prints is 0b, 0, 0x.
@@ -663 +663 @@
 IntegralFMTImpl128( unsigned int128, unsigned, 'u', "%    *ll ", "%    *.*ll " )
 #endif // __SIZEOF_INT128__
+#endif // 0
+
+#if 1
+#if defined( __SIZEOF_INT128__ )
+// Default prefix for non-decimal prints is 0b, 0, 0x.
+forall( dtype ostype | ostream( ostype ) )
+static inline void base_128( ostype & os, unsigned int128 val, unsigned int128 power, _Ostream_Manip(uint64_t) & f, unsigned int maxdig, unsigned int bits, unsigned int cnt = 0 ) {
+        int wd = 1;                                                                                     // f.wd is never 0 because 0 implies left-pad
+        if ( val > power ) {                                                            // subdivide value into printable 64-bit values
+                base_128( os, val / power, power, f, maxdig, bits, cnt + 1 ); // recursive
+                f.val = val % power;
+                if ( cnt == 1 && f.flags.left ) { wd = f.wd; f.wd = maxdig; } // copy f.wd and reset for printing middle chunk
+                (ostype &)(os | f);
+                if ( cnt == 1 ) {
+                        if ( f.flags.left ) { wd -= maxdig; f.wd = wd < 0 ? 1 : wd; } // update and restore f.wd for printing end chunk
+                        sepOff( os );                                                           // no seperator between chunks
+                } // if
+        } else {                                                                                        // print start chunk
+                f.val = val;
+                // f.pc is unsigned => use wd
+                if ( f.flags.pc && f.pc > maxdig * cnt ) { wd = f.pc - maxdig * cnt; f.pc = wd < 0 ? 0 : wd; }
+                else { f.flags.pc = false; f.pc = 0; }
+
+                if ( ! f.flags.left ) {                                                 // right justify
+                        wd = f.wd - maxdig * cnt;
+                        f.wd = wd < 0 ? 1 : wd;
+                        wd = maxdig;
+                } else {                                                                                // left justify
+                        if ( cnt != 0 ) {                                                       // value >= 2^64 ?
+                                unsigned int dig, bs = 0;
+                                // compute size of prefix digits and base
+                                if ( f.base == 'd' || f.base == 'u' ) { // no base prefix
+                                        dig = ceil( log10( f.val ) );           // use floating-point
+                                        if ( f.base == 'd' && (f.flags.neg || f.flags.sign) ) bs = 1; // sign ?
+                                } else {
+                                        dig = ceiling( high1( f.val ), bits );
+                                        if ( ! f.flags.nobsdp ) {                       // base prefix ?
+                                                if ( f.base == 'o' ) {
+                                                        // 0 prefix for octal is not added for precision with leading zero
+                                                        if ( f.pc <= dig ) bs = 1;      // 1 character prefix
+                                                } else bs = 2;                                  // 2 character prefix
+                                        } // if
+                                } // if
+                                wd = f.wd - (f.pc > dig ? f.pc : dig) - bs; // precision > leading digits ?
+                                if ( wd < 0 ) wd = 1;
+                                f.wd = 1;
+                        } // if
+                        // all manipulators handled implicitly for value < 2^64
+                } // if
+                // prior checks ensure wd not negative
+
+                if ( f.flags.neg ) f.val = -f.val;
+                (ostype &)(os | f);
+
+                // remaining middle and end chunks are padded with 0s on the left
+                if ( ! f.flags.left ) { f.flags.pad0 = true; f.flags.pc = false; } // left pad with 0s
+                else { f.pc = maxdig; f.flags.pc = true; }              // left pad with precision
+
+                if ( cnt != 0 ) sepOff( os );                                   // no seperator between chunks
+                f.wd = wd;                                                                              // reset f.wd for next chunk
+                f.flags.sign = false;                                                   // no leading +/- sign
+                f.flags.nobsdp = true;                                                  // no leading base prefix
+        } // if
+} // base_128
+
+#define IntegralFMTImpl128( T ) \
+forall( dtype ostype | ostream( ostype ) ) { \
+        ostype & ?|?( ostype & os, _Ostream_Manip(T) f ) { \
+                _Ostream_Manip(uint64_t) fmt; \
+                fmt.[wd, pc, base, all] = f.[wd, pc, base, all]; \
+                if ( f.base == 'b' | f.base == 'B' ) { \
+                        base_128( os, f.val, (unsigned int128)1 << 64, fmt, 64, 1 ); \
+                } else if ( f.base == 'o' ) { \
+                        base_128( os, f.val, (unsigned int128)1 << 63, fmt, 21, 3 ); \
+                } else if ( f.base == 'd' || f.base == 'u' ) { \
+                        if ( f.base == 'd' && f.val < 0 ) { f.val = -f.val; fmt.flags.neg = true; } \
+                        base_128( os, f.val, (unsigned int128)10_000_000_000_000_000_000UL, fmt, 19, 0 ); \
+                } else { \
+                        base_128( os, f.val, (unsigned int128)1 << 64, fmt, 16, 4 ); \
+                } /* if */ \
+                return os; \
+        } /* ?|? */ \
+        void ?|?( ostype & os, _Ostream_Manip(T) f ) { (ostype &)(os | f); ends( os ); } \
+} // distribution
+
+IntegralFMTImpl128( int128 )
+IntegralFMTImpl128( unsigned int128 )
+#endif // __SIZEOF_INT128__
+#endif // 0
 
 // *********************************** floating point ***********************************

libcfa/src/iostream.hfa

@@ -10 +10 @@
 // Created On       : Wed May 27 17:56:53 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 19 16:15:56 2020
-// Update Count     : 338
+// Last Modified On : Sat Jul  4 18:31:48 2020
+// Update Count     : 343
 //
 
@@ -166 +166 @@
                 unsigned char all;
                 struct {
+                        unsigned char neg:1;                                            // val is negative
                         unsigned char pc:1;                                                     // precision specified
                         unsigned char left:1;                                           // left justify
@@ -370 +371 @@
 
 static inline {
-        _Istream_Char ignore( const char c ) { return (_Istream_Char)@{ true }; }
+        _Istream_Char ignore( const char ) { return (_Istream_Char)@{ true }; }
         _Istream_Char & ignore( _Istream_Char & fmt ) { fmt.ignore = true; return fmt; }
 } // distribution
 forall( dtype istype | istream( istype ) ) istype & ?|?( istype & is, _Istream_Char f );
 
-forall( otype T )
+forall( dtype T | sized( T ) )
 struct _Istream_Manip {
         T & val;                                                                                        // polymorphic base-type

src/GenPoly/Specialize.cc

@@ -9 +9 @@
 // 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:40:49 2019
-// Update Count     : 32
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jul  2 17:42:00 2020
+// Update Count     : 33
 //
 
@@ -42 +42 @@
 
 namespace GenPoly {
-        struct Specialize final : public WithConstTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+        struct Specialize final : public WithConstTypeSubstitution,
+                        public WithDeclsToAdd, public WithVisitorRef<Specialize> {
                 Expression * postmutate( ApplicationExpr *applicationExpr );
                 Expression * postmutate( CastExpr *castExpr );
@@ -248 +249 @@
                 } // if
 
-                // handle any specializations that may still be present
-                std::string oldParamPrefix = paramPrefix;
-                paramPrefix += "p";
-                // save stmtsToAddBefore in oldStmts
-                std::list< Statement* > oldStmts;
-                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
-                appExpr->acceptMutator( *visitor );
-                paramPrefix = oldParamPrefix;
-                // write any statements added for recursive specializations into the thunk body
-                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
-                // restore oldStmts into stmtsToAddBefore
-                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
+                // Handle any specializations that may still be present.
+                {
+                        std::string oldParamPrefix = paramPrefix;
+                        paramPrefix += "p";
+                        std::list< Declaration * > oldDecls;
+                        oldDecls.splice( oldDecls.end(), declsToAddBefore );
+
+                        appExpr->acceptMutator( *visitor );
+                        // Write recursive specializations into the thunk body.
+                        for ( Declaration * decl : declsToAddBefore ) {
+                                thunkFunc->statements->kids.push_back( new DeclStmt( decl ) );
+                        }
+
+                        declsToAddBefore = std::move( oldDecls );
+                        paramPrefix = oldParamPrefix;
+                }
 
                 // add return (or valueless expression) to the thunk
@@ -270 +275 @@
                 thunkFunc->statements->kids.push_back( appStmt );
 
-                // add thunk definition to queue of statements to add
-                stmtsToAddBefore.push_back( new DeclStmt( thunkFunc ) );
+                // Add the thunk definition (converted to DeclStmt if appproprate).
+                declsToAddBefore.push_back( thunkFunc );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  7 17:56:02 2020
-// Update Count     : 891
+// Last Modified On : Mon Jul  6 09:33:32 2020
+// Update Count     : 892
 //
 
@@ -86 +86 @@
 class InitializerNode : public ParseNode {
   public:
-        InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
+        InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         InitializerNode( bool isDelete );

tests/copyfile.cfa

@@ -10 +10 @@
 // Created On       : Fri Jun 19 13:44:05 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jun 19 17:58:03 2020
-// Update Count     : 4
+// Last Modified On : Sun Jul  5 11:27:43 2020
+// Update Count     : 5
 // 
 
@@ -22 +22 @@
 
         try {
-                choose ( argc ) {
+                choose ( argc ) {                                                               // terminate if command-line errors
                   case 2, 3:
                         open( in, argv[1] );                                            // open input file first as output creates file
                         if ( argc == 3 ) open( out, argv[2] );          // do not create output unless input opens
                   case 1: ;                                                                             // use default files
-                  default:
+                  default:                                                                              // wrong number of options
                         exit | "Usage" | argv[0] | "[ input-file (default stdin) [ output-file (default stdout) ] ]";
                 } // choose

tests/exceptions/.expect/defaults.txt

@@ -3 +3 @@
 jump default handler.
 Catch unhandled_exception.
+cross terminate throw
+cross terminate default
+cross terminate catch
+cross resume throw
+cross resume default
+cross resume catch

tests/exceptions/defaults.cfa

@@ -30 +30 @@
                 throwResume (log_message){(char *)"Should be printed.\n"};
         } catchResume (log_message * this) {
-                printf(this->virtual_table->msg(this));
+                printf("%s", this->virtual_table->msg(this));
         }
         // But we don't have to:
@@ -69 +69 @@
 }
 
+TRIVIAL_EXCEPTION(second);
+
+void cross_test(void) {
+        void defaultTerminationHandler(first &) {
+                printf("cross terminate default\n");
+                throw (second){};
+        }
+        void defaultResumptionHandler(first &) {
+                printf("cross resume default\n");
+                throwResume (second){};
+        }
+        try {
+                printf("cross terminate throw\n");
+                throw (first){};
+        } catch (second *) {
+                printf("cross terminate catch\n");
+        }
+        try {
+                printf("cross resume throw\n");
+                throwResume (first){};
+        } catchResume (second *) {
+                printf("cross resume catch\n");
+        }
+}
+
 int main(int argc, char * argv[]) {
         log_test();
         jump_test();
         unhandled_test();
+        cross_test();
 }

tests/manipulatorsOutput3.cfa

@@ -13 +13 @@
     sout | sign(x);
     sout | nl;
-#if 1
+
     sout | bin(x);
     sout | upcase(bin(x));
@@ -124 +124 @@
     sout | nl;
 
-    
+
+    // extras
+    sout | "extras";
     sout | bin(divisor);
     sout | upcase(bin(divisor));
@@ -140 +142 @@
     sout | left(sign(wd(0,40, divisor))) | 'X';
     printf( "%-+1.40dX\n", 123456789 );
-#endif // 0
+
+    int128 i128;
+    unsigned int128 ui128;
+
+    i128 = -10;
+    for ( 25 ) {
+        sout | left( sign( wd( 20, i128 ) ) ) | left( wd( 20, hex( i128 ) ) ) | left( wd( 20, oct( i128 ) ) );
+        sout | left( wd( 20, bin( i128 ) ) );
+        i128 += 1;
+    }
+    sout | nl;
+
+    i128 = 0x7fffffffffffffff;
+    i128 <<= 64;
+    i128 += 0xfffffffffffffffa;
+
+    for ( 20 ) {
+        sout | i128;
+        sout | left( sign( wd( 45, i128 ) ) ) | left( wd( 45, hex( i128 ) ) ) | left( wd( 45, oct( i128 ) ) );
+        sout | left( wd( 45, bin( i128 ) ) );
+        i128 += 1;
+    }
+    sout | nl;
+
+    ui128 = 0x7fffffffffffffff;
+    ui128 <<= 64;
+    ui128 += 0xfffffffffffffffa;
+    
+    for ( 20 ) {
+        sout | ui128;
+        ui128 += 1;
+    }
+    sout | nl;
+
+    ui128 = 0xffffffffffffffff;
+    ui128 <<= 64;
+    ui128 += 0xfffffffffffffffa;
+    
+    for ( 20 ) {
+        sout | ui128;
+        ui128 += 1;
+    }
 }

tests/pybin/test_run.py

@@ -69 +69 @@
                         else :                                          text = "FAILED with code %d" % retcode
 
-                text += "    C%s - R%s" % (cls.fmtDur(duration[0]), cls.fmtDur(duration[1]))
+                text += "    C%s - R%s" % (fmtDur(duration[0]), fmtDur(duration[1]))
                 return text
-
-        @staticmethod
-        def fmtDur( duration ):
-                if duration :
-                        hours, rem = divmod(duration, 3600)
-                        minutes, rem = divmod(rem, 60)
-                        seconds, millis = divmod(rem, 1)
-                        return "%2d:%02d.%03d" % (minutes, seconds, millis * 1000)
-                return " n/a"

tests/pybin/tools.py

@@ -387 +387 @@
                 while True:
                         yield i.next(max(expire - time.time(), 0))
+
+def fmtDur( duration ):
+        if duration :
+                hours, rem = divmod(duration, 3600)
+                minutes, rem = divmod(rem, 60)
+                seconds, millis = divmod(rem, 1)
+                return "%2d:%02d.%03d" % (minutes, seconds, millis * 1000)
+        return " n/a"

tests/test.py

@@ -361 +361 @@
 
                 # for each build configurations, run the test
-                for arch, debug, install in itertools.product(settings.all_arch, settings.all_debug, settings.all_install):
-                        settings.arch    = arch
-                        settings.debug   = debug
-                        settings.install = install
-
-                        # filter out the tests for a different architecture
-                        # tests are the same across debug/install
-                        local_tests = settings.arch.filter( tests )
-                        options.jobs, forceJobs = job_count( options, local_tests )
-                        settings.update_make_cmd(forceJobs, options.jobs)
-
-                        # check the build configuration works
-                        settings.validate()
-
-                        # print configuration
-                        print('%s %i tests on %i cores (%s:%s)' % (
-                                'Regenerating' if settings.generating else 'Running',
-                                len(local_tests),
-                                options.jobs,
-                                settings.arch.string,
-                                settings.debug.string
-                        ))
-
-                        # otherwise run all tests and make sure to return the correct error code
-                        failed = run_tests(local_tests, options.jobs)
-                        if failed:
-                                result = 1
-                                if not settings.continue_:
-                                        break
-
-
+                with Timed() as total_dur:
+                        for arch, debug, install in itertools.product(settings.all_arch, settings.all_debug, settings.all_install):
+                                settings.arch    = arch
+                                settings.debug   = debug
+                                settings.install = install
+
+                                # filter out the tests for a different architecture
+                                # tests are the same across debug/install
+                                local_tests = settings.arch.filter( tests )
+                                options.jobs, forceJobs = job_count( options, local_tests )
+                                settings.update_make_cmd(forceJobs, options.jobs)
+
+                                # check the build configuration works
+                                settings.validate()
+
+                                # print configuration
+                                print('%s %i tests on %i cores (%s:%s)' % (
+                                        'Regenerating' if settings.generating else 'Running',
+                                        len(local_tests),
+                                        options.jobs,
+                                        settings.arch.string,
+                                        settings.debug.string
+                                ))
+
+                                # otherwise run all tests and make sure to return the correct error code
+                                failed = run_tests(local_tests, options.jobs)
+                                if failed:
+                                        result = 1
+                                        if not settings.continue_:
+                                                break
+
+                print('Tests took %s' % fmtDur( total_dur.duration ))
                 sys.exit( failed )