Changeset 3e1cd17

Timestamp:

Apr 12, 2024, 8:51:19 AM (12 months ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Children:

b1b3df5

Parents:

21e6da5 (diff), b78c54f (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/concurrency/kernel/cluster.cfa (modified) (3 diffs)
• libcfa/src/concurrency/kernel/startup.cfa (modified) (2 diffs)
• libcfa/src/heap.cfa (modified) (28 diffs)
• libcfa/src/heap.hfa (modified) (3 diffs)
• libcfa/src/stdlib.hfa (modified) (5 diffs)
• src/Parser/StatementNode.cc (modified) (10 diffs)
• src/Parser/module.mk (modified) (1 diff)
• src/Parser/parserutility.cc (deleted)
• src/Parser/parserutility.h (modified) (1 diff)
• src/ResolvExpr/CandidateFinder.cpp (modified) (4 diffs)
• src/ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• src/ResolvExpr/Resolver.cc (modified) (7 diffs)

libcfa/src/concurrency/kernel/cluster.cfa ¶

@@ -341 +341 @@
         // Make sure that everything is consistent
         /* paranoid */ check_readyQ( cltr );
-        /* paranoid */ verify( (target == 0) == (cltr->sched.caches == 0p) );
+//      /* paranoid */ verify( (target == 0) == (cltr->sched.caches == 0p) );
 
         __cfadbg_print_safe(ready_queue, "Kernel : Growing ready queue done\n");
@@ -416 +416 @@
                 fix_times(readyQ.tscs, ncount);
         }
+
         cltr->sched.caches = alloc( target, cltr->sched.caches`realloc );
 
@@ -428 +429 @@
 
         // Make sure that everything is consistent
-        /* paranoid */ verify( (target == 0) == (cltr->sched.caches == 0p) );
+//      /* paranoid */ verify( (target == 0) == (cltr->sched.caches == 0p) );
         /* paranoid */ check_readyQ( cltr );
 

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

@@ -672 +672 @@
         uint_fast32_t last_size = ready_mutate_lock();
 
-                // Adjust the ready queue size
-                ready_queue_shrink( &this );
+        // Adjust the ready queue size
+        ready_queue_shrink( &this );
 
         // Unlock the RWlock
@@ -682 +682 @@
         /* paranoid */ verify( this.sched.readyQ.tscs == 0p );
         /* paranoid */ verify( this.sched.readyQ.count == 0 );
-        /* paranoid */ verify( this.sched.io.tscs == 0p );
-        /* paranoid */ verify( this.sched.caches == 0p );
+//      /* paranoid */ verify( this.sched.io.tscs == 0p );
+//      /* paranoid */ verify( this.sched.caches == 0p );
 
         enable_interrupts( false ); // Don't poll, could be in main cluster

libcfa/src/heap.cfa ¶

@@ -10 +10 @@
 // Created On       : Tue Dec 19 21:58:35 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jan  3 21:30:54 2024
-// Update Count     : 1619
+// Last Modified On : Sun Apr  7 21:54:29 2024
+// Update Count     : 1644
 //
 
@@ -114 +114 @@
 
 
-// generic Bsearchl does not inline, so substitute with hand-coded binary-search.
+// CFA generic Bsearchl does not inline, so substitute with hand-coded binary-search.
 inline __attribute__((always_inline))
 static size_t Bsearchl( unsigned int key, const unsigned int vals[], size_t dim ) {
@@ -190 +190 @@
                 unsigned int realloc_calls, realloc_0_calls;
                 unsigned long long int realloc_storage_request, realloc_storage_alloc;
-                unsigned int free_calls, free_null_calls;
+                unsigned int free_calls, free_null_0_calls;
                 unsigned long long int free_storage_request, free_storage_alloc;
                 unsigned int return_pulls, return_pushes;
@@ -232 +232 @@
                 struct Header {                                                                 // header
                         union Kind {
-                                struct RealHeader {
+                                struct RealHeader {                                             // 4-byte word => 8-byte header, 8-byte word => 16-byte header
                                         union {
-                                                struct {                                                // 4-byte word => 8-byte header, 8-byte word => 16-byte header
-                                                        union {
-                                                                // 2nd low-order bit => zero filled, 3rd low-order bit => mmapped
-                                                                // FreeHeader * home;           // allocated block points back to home locations (must overlay alignment)
-                                                                void * home;                    // allocated block points back to home locations (must overlay alignment)
-                                                                size_t blockSize;               // size for munmap (must overlay alignment)
-                                                                Storage * next;                 // freed block points to next freed block of same size
-                                                        };
-                                                        size_t size;                            // allocation size in bytes
-                                                };
+                                                // 2nd low-order bit => zero filled, 3rd low-order bit => mmapped
+                                                // FreeHeader * home;                   // allocated block points back to home locations (must overlay alignment)
+                                                void * home;                                    // allocated block points back to home locations (must overlay alignment)
+                                                size_t blockSize;                               // size for munmap (must overlay alignment)
+                                                Storage * next;                                 // freed block points to next freed block of same size
                                         };
+                                        size_t size;                                            // allocation size in bytes
                                 } real; // RealHeader
 
@@ -261 +257 @@
 
         struct CALIGN FreeHeader {
-                size_t blockSize CALIGN;                                                // size of allocations on this list
                 #ifdef OWNERSHIP
                 #ifdef RETURNSPIN
@@ -271 +266 @@
                 Storage * freeList;                                                             // thread free list
                 Heap * homeManager;                                                             // heap owner (free storage to bucket, from bucket to heap)
+                size_t blockSize;                                                               // size of allocations on this list
         }; // FreeHeader
 
@@ -369 +365 @@
 static __thread size_t PAD1 CALIGN TLSMODEL __attribute__(( unused )); // protect false sharing
 static __thread Heap * heapManager CALIGN TLSMODEL;
-static  __thread bool heapManagerBootFlag CALIGN TLSMODEL = false;
+static __thread bool heapManagerBootFlag CALIGN TLSMODEL = false;
 static __thread size_t PAD2 CALIGN TLSMODEL __attribute__(( unused )); // protect further false sharing
 
@@ -595 +591 @@
 
 #ifdef __STATISTICS__
-static HeapStatistics stats;                                                    // zero filled
-
 #define prtFmt \
         "\nHeap statistics: (storage request / allocation)\n" \
@@ -607 +601 @@
         "  resize    >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n" \
         "  realloc   >0 calls %'u; 0 calls %'u; storage %'llu / %'llu bytes\n" \
-        "  free      !null calls %'u; null calls %'u; storage %'llu / %'llu bytes\n" \
+        "  free      !null calls %'u; null/0 calls %'u; storage %'llu / %'llu bytes\n" \
         "  return    pulls %'u; pushes %'u; storage %'llu / %'llu bytes\n" \
         "  sbrk      calls %'u; storage %'llu bytes\n" \
@@ -627 +621 @@
                         resize_calls, resize_0_calls, resize_storage_request, resize_storage_alloc,
                         realloc_calls, realloc_0_calls, realloc_storage_request, realloc_storage_alloc,
-                        free_calls, free_null_calls, free_storage_request, free_storage_alloc,
+                        free_calls, free_null_0_calls, free_storage_request, free_storage_alloc,
                         return_pulls, return_pushes, return_storage_request, return_storage_alloc,
                         sbrk_calls, sbrk_storage,
@@ -650 +644 @@
         "<total type=\"resize\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
         "<total type=\"realloc\" >0 count=\"%'u;\" 0 count=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
-        "<total type=\"free\" !null=\"%'u;\" 0 null=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
+        "<total type=\"free\" !null=\"%'u;\" 0 null/0=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
         "<total type=\"return\" pulls=\"%'u;\" 0 pushes=\"%'u;\" size=\"%'llu / %'llu\"/> bytes\n" \
         "<total type=\"sbrk\" count=\"%'u;\" size=\"%'llu\"/> bytes\n" \
@@ -670 +664 @@
                         resize_calls, resize_0_calls, resize_storage_request, resize_storage_alloc,
                         realloc_calls, realloc_0_calls, realloc_storage_request, realloc_storage_alloc,
-                        free_calls, free_null_calls, free_storage_request, free_storage_alloc,
+                        free_calls, free_null_0_calls, free_storage_request, free_storage_alloc,
                         return_pulls, return_pushes, return_storage_request, return_storage_alloc,
                         sbrk_calls, sbrk_storage,
@@ -799 +793 @@
         } else {
                 fakeHeader( header, alignment );
-                if ( unlikely( MmappedBit( header ) ) ) {               // mmapped ?
+                if ( unlikely( MmappedBit( header ) ) ) {               // mmapped storage ?
                         verify( addr < heapBegin || heapEnd < addr );
                         size = ClearStickyBits( header->kind.real.blockSize ); // mmap size
+                        freeHead = 0p;                                                          // prevent uninitialized warning
                         return true;
                 } // if
@@ -904 +899 @@
 
 
-#define BOOT_HEAP_MANAGER \
-        if ( unlikely( ! heapMasterBootFlag ) ) { \
-                heapManagerCtor(); /* trigger for first heap */ \
-        } /* if */
-
 #ifdef __STATISTICS__
 #define STAT_NAME __counter
 #define STAT_PARM , unsigned int STAT_NAME
 #define STAT_ARG( name ) , name
-#define STAT_0_CNT( counter ) stats.counters[counter].calls_0 += 1
+#define STAT_0_CNT( counter ) heapManager->stats.counters[counter].calls_0 += 1
 #else
 #define STAT_NAME
@@ -921 +911 @@
 #endif // __STATISTICS__
 
-// Uncomment to get allocation addresses for a 0-sized allocation rather than a null pointer.
-//#define __NONNULL_0_ALLOC__
-#if ! defined( __NONNULL_0_ALLOC__ )
-#define __NULL_0_ALLOC__ unlikely( size == 0 ) ||               /* 0 BYTE ALLOCATION RETURNS NULL POINTER */
+#define BOOT_HEAP_MANAGER \
+        if ( unlikely( ! heapMasterBootFlag ) ) { \
+                heapManagerCtor(); /* trigger for first heap */ \
+        } /* if */ \
+        verify( heapManager );
+
+#define __NONNULL_0_ALLOC__ /* Uncomment to return non-null address for malloc( 0 ). */
+#ifndef __NONNULL_0_ALLOC__
+#define __NULL_0_ALLOC__( counter, ... ) /* 0 byte allocation returns null pointer */ \
+        if ( unlikely( size == 0 ) ) { \
+                STAT_0_CNT( counter ); \
+                __VA_ARGS__; /* call routine, if specified */ \
+                return 0p; \
+        } /* if */
 #else
-#define __NULL_0_ALLOC__
+#define __NULL_0_ALLOC__( counter, ... )
 #endif // __NONNULL_0_ALLOC__
+
+#ifdef __DEBUG__
+#define __OVERFLOW_MALLOC__( ... ) \
+        if ( unlikely( size > ULONG_MAX - sizeof(Heap.Storage) ) ) { /* error check */ \
+                __VA_ARGS__; /* call routine, if specified */ \
+                return 0p; \
+        } /* if */
+#else
+#define __OVERFLOW_MALLOC__( ... )
+#endif // __DEBUG__
 
 #define PROLOG( counter, ... ) \
         BOOT_HEAP_MANAGER; \
-        if ( \
-                __NULL_0_ALLOC__ \
-                unlikely( size > ULONG_MAX - sizeof(Heap.Storage) ) ) { /* error check */ \
-                STAT_0_CNT( counter ); \
-                __VA_ARGS__; \
-                return 0p; \
-        } /* if */
-
+        __NULL_0_ALLOC__( counter, __VA_ARGS__ ) \
+        __OVERFLOW_MALLOC__( __VA_ARGS__ )
 
 #define SCRUB_SIZE 1024lu
@@ -948 +952 @@
         PROLOG( STAT_NAME );
 
-        verify( heapManager );
         Heap.Storage * block;                                                           // pointer to new block of storage
 
@@ -956 +959 @@
 
         #ifdef __STATISTICS__
-        stats.counters[STAT_NAME].calls += 1;
+        #ifdef __NONNULL_0_ALLOC__
+        if ( unlikely( size == 0 ) )                                            // malloc( 0 ) ?
+                stats.counters[STAT_NAME].calls_0 += 1;
+        else
+        #endif // __NONNULL_0_ALLOC__
+                stats.counters[STAT_NAME].calls += 1;
         stats.counters[STAT_NAME].request += size;
         #endif // __STATISTICS__
@@ -1078 +1086 @@
 
 static void doFree( void * addr ) libcfa_nopreempt with( *heapManager ) {
+        // char buf[64];
+        // int len = sprintf( buf, "doFree addr %p\n", addr );
+        // write( 2, buf, len );
+
         verify( addr );
 
@@ -1091 +1103 @@
         #endif // __STATISTICS__ || __CFA_DEBUG__
 
+        // Do not move these down because heap can be null!
         #ifdef __STATISTICS__
+        #ifdef __NONNULL_0_ALLOC__
+        if ( unlikely( rsize == 0 ) )                                           // malloc( 0 ) ?
+                stats.free_null_0_calls += 1;
+        else
+        #endif // __NONNULL_0_ALLOC__
+                heapManager->stats.free_calls += 1;                             // count free amd implicit frees from resize/realloc
         stats.free_storage_request += rsize;
         stats.free_storage_alloc += size;
@@ -1117 +1136 @@
                 } // if
         } else {
+                assert( freeHead );
                 #ifdef __CFA_DEBUG__
                 // memset is NOT always inlined!
@@ -1321 +1341 @@
         // call to malloc(), alloc(), calloc() or realloc(). If the area pointed to was moved, a free(oaddr) is done.
         void * resize( void * oaddr, size_t size ) libcfa_public {
-          if ( unlikely( oaddr == 0p ) ) {                              // => malloc( size )
+          if ( unlikely( oaddr == 0p ) ) {                                      // => malloc( size )
                         return doMalloc( size STAT_ARG( RESIZE ) );
                 } // if
@@ -1333 +1353 @@
 
                 size_t odsize = DataStorage( bsize, oaddr, header ); // data storage available in bucket
-                // same size, DO NOT preserve STICKY PROPERTIES.
+                // same size, DO NOT PRESERVE STICKY PROPERTIES.
                 if ( oalign == libAlign() && size <= odsize && odsize <= size * 2 ) { // allow 50% wasted storage for smaller size
                         ClearZeroFillBit( header );                                     // no alignment and turn off 0 fill
@@ -1346 +1366 @@
                 } // if
 
-                // change size, DO NOT preserve STICKY PROPERTIES.
+                // change size, DO NOT PRESERVE STICKY PROPERTIES.
                 doFree( oaddr );                                                                // free previous storage
 
@@ -1356 +1376 @@
         // the old and new sizes.
         void * realloc( void * oaddr, size_t size ) libcfa_public {
+                // char buf[64];
+                // int len = sprintf( buf, "realloc1 oaddr %p size %d\n", oaddr, size );
+                // write( 2, buf, len );
           if ( unlikely( oaddr == 0p ) ) {                                      // => malloc( size )
                   return doMalloc( size STAT_ARG( REALLOC ) );
@@ -1498 +1521 @@
                 } // if
 
-                #ifdef __STATISTICS__
-                incCalls( FREE );
-                #endif // __STATISTICS__
-
                 doFree( addr );                                                                 // handles heapManager == nullptr
         } // free
@@ -1579 +1598 @@
                 #endif // __STATISTICS__
         } // malloc_stats_clear
-
 
         // Changes the file descriptor where malloc_stats() writes statistics.
@@ -1700 +1718 @@
         } // if
 
-        // change size, DO NOT preserve STICKY PROPERTIES.
+        // change size, DO NOT PRESERVE STICKY PROPERTIES.
         doFree( oaddr );                                                                        // free previous storage
         return memalignNoStats( nalign, size STAT_ARG( RESIZE ) ); // create new aligned area
@@ -1707 +1725 @@
 
 void * realloc( void * oaddr, size_t nalign, size_t size ) libcfa_public {
+        // char buf[64];
+        // int len = sprintf( buf, "realloc2 oaddr %p size %d\n", oaddr, size );
+        // write( 2, buf, len );
   if ( unlikely( oaddr == 0p ) ) {                                              // => malloc( size )
                 return memalignNoStats( nalign, size STAT_ARG( REALLOC ) );

libcfa/src/heap.hfa ¶

@@ -10 +10 @@
 // Created On       : Tue May 26 11:23:55 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 11 11:18:18 2023
-// Update Count     : 24
+// Last Modified On : Mon Apr  1 09:36:20 2024
+// Update Count     : 25
 // 
 
@@ -46 +46 @@
 } // extern "C"
 
+// New allocation operations.
 void * resize( void * oaddr, size_t alignment, size_t size );
 void * realloc( void * oaddr, size_t alignment, size_t size );
@@ -51 +52 @@
 
 // Local Variables: //
-// mode: c //
 // tab-width: 4 //
 // End: //

libcfa/src/stdlib.hfa ¶

@@ -10 +10 @@
 // Created On       : Thu Jan 28 17:12:35 2016
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Mar 17 08:25:31 2024
-// Update Count     : 796
+// Last Modified On : Fri Apr 12 07:39:15 2024
+// Update Count     : 812
 //
 
@@ -109 +109 @@
         1. Replace the current forall-block that contains defintions of S_fill and S_realloc with following:
                 forall( T & | sized(T) ) {
-                        union  U_fill           { char c; T * a; T t; };
-                        struct S_fill           { char tag; U_fill(T) fill; };
-                        struct S_realloc        { inline T *; };
+                        union  U_fill { char c; T * a; T t; };
+                        struct S_fill { char tag; U_fill(T) fill; };
+                        struct S_realloc { inline T *; };
                 }
 
         2. Replace all current postfix-fill functions with following for updated S_fill:
-                S_fill(T) ?`fill( char a )                                      { S_fill(T) ret = {'c'}; ret.fill.c = a; return ret; }
-                S_fill(T) ?`fill( T    a )                                      { S_fill(T) ret = {'t'}; memcpy(&ret.fill.t, &a, sizeof(T)); return ret; }
-                S_fill(T) ?`fill( T    a[], size_t nmemb )      { S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
+                S_fill(T) ?`fill( char a ) { S_fill(T) ret = {'c'}; ret.fill.c = a; return ret; }
+                S_fill(T) ?`fill( T a ) { S_fill(T) ret = {'t'}; memcpy(&ret.fill.t, &a, sizeof(T)); return ret; }
+                S_fill(T) ?`fill( T a[], size_t nmemb ) { S_fill(T) ret = {'a', nmemb}; ret.fill.a = a; return ret; }
 
         3. Replace the alloc_internal$ function which is outside ttype forall-block with following function:
@@ -148 +148 @@
 */
 
-typedef struct S_align                  { inline size_t;  } T_align;
-typedef struct S_resize                 { inline void *;  }     T_resize;
+typedef struct S_align { inline size_t;  } T_align;
+typedef struct S_resize { inline void *;  }     T_resize;
 
 forall( T & ) {
-        struct S_fill           { char tag; char c; size_t size; T * at; char t[50]; };
-        struct S_realloc        { inline T *; };
+        struct S_fill { char tag; char c; size_t size; T * at; char t[50]; };
+        struct S_realloc { inline T *; };
 }
 
-static inline T_align   ?`align   ( size_t a )  { return (T_align){a}; }
-static inline T_resize  ?`resize  ( void * a )  { return (T_resize){a}; }
-
+static inline T_align ?`align( size_t a ) { return (T_align){a}; }
+static inline T_resize ?`resize( void * a )     { return (T_resize){a}; }
+
+extern "C" ssize_t write(int fd, const void *buf, size_t count);
 static inline forall( T & | sized(T) ) {
         S_fill(T) ?`fill ( T t ) {
@@ -169 +170 @@
                 return ret;
         }
-        S_fill(T)               ?`fill ( zero_t ) = void; // FIX ME: remove this once ticket 214 is resolved
-        S_fill(T)               ?`fill ( T * a )                                { return (S_fill(T)){ 'T', '0', 0, a }; } // FIX ME: remove this once ticket 214 is resolved
-        S_fill(T)               ?`fill ( char c )                               { return (S_fill(T)){ 'c', c }; }
-        S_fill(T)               ?`fill ( T a[], size_t nmemb )  { return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; }
-
-        S_realloc(T)    ?`realloc ( T * a )                             { return (S_realloc(T)){a}; }
+        S_fill(T) ?`fill ( zero_t ) = void; // FIX ME: remove this once ticket 214 is resolved
+        S_fill(T) ?`fill ( T * a ) { return (S_fill(T)){ 'T', '0', 0, a }; } // FIX ME: remove this once ticket 214 is resolved
+        S_fill(T) ?`fill ( char c ) { return (S_fill(T)){ 'c', c };     }
+        S_fill(T) ?`fill ( T a[], size_t nmemb ) { return (S_fill(T)){ 'a', '0', nmemb * sizeof(T), a }; }
+
+        S_realloc(T) ?`realloc ( T * a ) { return (S_realloc(T)){a}; }
 
         T * alloc_internal$( void * Resize, T * Realloc, size_t Align, size_t Dim, S_fill(T) Fill ) {
@@ -182 +183 @@
 
                 if ( Resize ) {
-                        ptr = (T*) (void *) resize( (void *)Resize, Align, Dim * size );
+                        ptr = (T*)(void *)resize( (void *)Resize, Align, Dim * size );
                 } else if ( Realloc ) {
                         if ( Fill.tag != '0' ) copy_end = min(malloc_size( Realloc ), Dim * size );
-                        ptr = (T *) (void *) realloc( (void *)Realloc, Align, Dim * size );
+                        ptr = (T *)(void *)realloc( (void *)Realloc, Align, Dim * size );
                 } else {
-                        ptr = (T *) (void *) memalign( Align, Dim * size );
+                        ptr = (T *)(void *) memalign( Align, Dim * size );
                 }
 

src/Parser/StatementNode.cc ¶

@@ -122 +122 @@
         ast::Expr * cond = nullptr;
         if ( ctl->condition ) {
-                // compare the provided condition against 0
-                cond = notZeroExpr( maybeMoveBuild( ctl->condition ) );
+                cond = maybeMoveBuild( ctl->condition );
         } else {
                 for ( ast::ptr<ast::Stmt> & stmt : inits ) {
@@ -129 +128 @@
                         auto declStmt = stmt.strict_as<ast::DeclStmt>();
                         auto dwt = declStmt->decl.strict_as<ast::DeclWithType>();
-                        ast::Expr * nze = notZeroExpr( new ast::VariableExpr( dwt->location, dwt ) );
+                        ast::Expr * nze = new ast::VariableExpr( dwt->location, dwt );
                         cond = cond ? new ast::LogicalExpr( dwt->location, cond, nze, ast::AndExpr ) : nze;
                 }
@@ -200 +199 @@
         // do-while cannot have declarations in the contitional, so init is always empty
         return new ast::WhileDoStmt( location,
-                notZeroExpr( maybeMoveBuild( ctl ) ),
+                maybeMoveBuild( ctl ),
                 buildMoveSingle( stmt ),
                 buildMoveOptional( else_ ),
@@ -213 +212 @@
 
         ast::Expr * astcond = nullptr;                                          // maybe empty
-        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        astcond = maybeMoveBuild( forctl->condition );
 
         ast::Expr * astincr = nullptr;                                          // maybe empty
@@ -330 +329 @@
         clause->target = maybeBuild( targetExpr );
         clause->stmt = maybeMoveBuild( stmt );
-        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->when_cond = maybeMoveBuild( when );
 
         ExpressionNode * next = targetExpr->next;
@@ -345 +344 @@
 ast::WaitForStmt * build_waitfor_else( const CodeLocation & location, ast::WaitForStmt * existing, ExpressionNode * when, StatementNode * stmt ) {
         existing->else_stmt = maybeMoveBuild( stmt );
-        existing->else_cond = notZeroExpr( maybeMoveBuild( when ) );
+        existing->else_cond = maybeMoveBuild( when );
 
         (void)location;
@@ -354 +353 @@
         existing->timeout_time = maybeMoveBuild( timeout );
         existing->timeout_stmt = maybeMoveBuild( stmt );
-        existing->timeout_cond = notZeroExpr( maybeMoveBuild( when ) );
+        existing->timeout_cond = maybeMoveBuild( when );
 
         (void)location;
@@ -362 +361 @@
 ast::WaitUntilStmt::ClauseNode * build_waituntil_clause( const CodeLocation & loc, ExpressionNode * when, ExpressionNode * targetExpr, StatementNode * stmt ) {
         ast::WhenClause * clause = new ast::WhenClause( loc );
-        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->when_cond = maybeMoveBuild( when );
         clause->stmt = maybeMoveBuild( stmt );
         clause->target = maybeMoveBuild( targetExpr );
@@ -369 +368 @@
 ast::WaitUntilStmt::ClauseNode * build_waituntil_else( const CodeLocation & loc, ExpressionNode * when, StatementNode * stmt ) {
         ast::WhenClause * clause = new ast::WhenClause( loc );
-        clause->when_cond = notZeroExpr( maybeMoveBuild( when ) );
+        clause->when_cond = maybeMoveBuild( when );
         clause->stmt = maybeMoveBuild( stmt );
         return new ast::WaitUntilStmt::ClauseNode( ast::WaitUntilStmt::ClauseNode::Op::ELSE, clause );
@@ -508 +507 @@
 
         ast::Expr * astcond = nullptr;                                          // maybe empty
-        astcond = notZeroExpr( maybeMoveBuild( forctl->condition ) );
+        astcond = maybeMoveBuild( forctl->condition );
 
         ast::Expr * astincr = nullptr;                                          // maybe empty

src/Parser/module.mk ¶

@@ -31 +31 @@
        Parser/parser.yy \
        Parser/ParserTypes.h \
-       Parser/parserutility.cc \
        Parser/parserutility.h \
        Parser/RunParser.cpp \

src/Parser/parserutility.h ¶

@@ -17 +17 @@
 
 #include "AST/Copy.hpp"            // for shallowCopy
-namespace ast {
-        class Expr;
-}
-
-ast::Expr * notZeroExpr( const ast::Expr *orig );
 
 template< typename T >

src/ResolvExpr/CandidateFinder.cpp ¶

@@ -46 +46 @@
 #include "AST/Type.hpp"
 #include "Common/utility.h"       // for move, copy
-#include "Parser/parserutility.h" // for notZeroExpr
 #include "SymTab/Mangler.h"
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
@@ -1587 +1586 @@
         void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) {
                 CandidateFinder finder1( context, tenv );
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( logicalExpr->arg1 );
+                ast::ptr<ast::Expr> arg1 = createCondExpr( logicalExpr->arg1 );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
                 if ( finder1.candidates.empty() ) return;
 
                 CandidateFinder finder2( context, tenv );
-                ast::ptr<ast::Expr> arg2 = notZeroExpr( logicalExpr->arg2 );
+                ast::ptr<ast::Expr> arg2 = createCondExpr( logicalExpr->arg2 );
                 finder2.find( arg2, ResolveMode::withAdjustment() );
                 if ( finder2.candidates.empty() ) return;
@@ -1618 +1617 @@
         void Finder::postvisit( const ast::ConditionalExpr * conditionalExpr ) {
                 // candidates for condition
-                ast::ptr<ast::Expr> arg1 = notZeroExpr( conditionalExpr->arg1 );
+                ast::ptr<ast::Expr> arg1 = createCondExpr( conditionalExpr->arg1 );
                 CandidateFinder finder1( context, tenv );
                 finder1.find( arg1, ResolveMode::withAdjustment() );
@@ -2201 +2200 @@
 }
 
+const ast::Expr * createCondExpr( const ast::Expr * expr ) {
+        assert( expr );
+        return new ast::CastExpr( expr->location,
+                ast::UntypedExpr::createCall( expr->location,
+                        "?!=?",
+                        {
+                                expr,
+                                new ast::ConstantExpr( expr->location,
+                                        new ast::ZeroType(), "0", std::make_optional( 0ull )
+                                ),
+                        }
+                ),
+                new ast::BasicType( ast::BasicType::SignedInt )
+        );
+}
+
 } // namespace ResolvExpr
 

src/ResolvExpr/CandidateFinder.hpp ¶

@@ -70 +70 @@
         const ast::Expr * expr, Cost & cost );
 
+/// Wrap an expression to convert the result to a conditional result.
+const ast::Expr * createCondExpr( const ast::Expr * expr );
+
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc ¶

@@ -340 +340 @@
         }
 
+        ast::ptr< ast::Expr > findCondExpression(
+                const ast::Expr * untyped, const ResolveContext & context
+        ) {
+                if ( nullptr == untyped ) return untyped;
+                ast::ptr<ast::Expr> condExpr = createCondExpr( untyped );
+                return findIntegralExpression( condExpr, context );
+        }
+
         /// check if a type is a character type
         bool isCharType( const ast::Type * t ) {
@@ -356 +364 @@
                 return it != end;
         }
-}
+} // anonymous namespace
 
 class Resolver final
@@ -729 +737 @@
 const ast::IfStmt * Resolver::previsit( const ast::IfStmt * ifStmt ) {
         return ast::mutate_field(
-                ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) );
+                ifStmt, &ast::IfStmt::cond, findCondExpression( ifStmt->cond, context ) );
 }
 
 const ast::WhileDoStmt * Resolver::previsit( const ast::WhileDoStmt * whileDoStmt ) {
         return ast::mutate_field(
-                whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) );
+                whileDoStmt, &ast::WhileDoStmt::cond, findCondExpression( whileDoStmt->cond, context ) );
 }
 
@@ -740 +748 @@
         if ( forStmt->cond ) {
                 forStmt = ast::mutate_field(
-                        forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, context ) );
+                        forStmt, &ast::ForStmt::cond, findCondExpression( forStmt->cond, context ) );
         }
 
@@ -1075 +1083 @@
 
                 // Resolve the conditions as if it were an IfStmt, statements normally
-                clause2->when_cond = findSingleExpression( clause.when_cond, context );
+                clause2->when_cond = findCondExpression( clause.when_cond, context );
                 clause2->stmt = clause.stmt->accept( *visitor );
 
@@ -1089 +1097 @@
                         new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
                 auto timeout_time = findSingleExpression( stmt->timeout_time, target, context );
-                auto timeout_cond = findSingleExpression( stmt->timeout_cond, context );
+                auto timeout_cond = findCondExpression( stmt->timeout_cond, context );
                 auto timeout_stmt = stmt->timeout_stmt->accept( *visitor );
 
@@ -1102 +1110 @@
         if ( stmt->else_stmt ) {
                 // resolve the condition like IfStmt, stmts normally
-                auto else_cond = findSingleExpression( stmt->else_cond, context );
+                auto else_cond = findCondExpression( stmt->else_cond, context );
                 auto else_stmt = stmt->else_stmt->accept( *visitor );