Changes in / [9509d67a:c8ec58e]

Files:

• libcfa/prelude/extras.c (modified) (1 diff)
• libcfa/prelude/extras.regx2 (modified) (1 diff)
• libcfa/src/clock.hfa (modified) (2 diffs)
• libcfa/src/concurrency/kernel/cluster.hfa (modified) (2 diffs)
• libcfa/src/heap.cfa (modified) (3 diffs)
• libcfa/src/heap.hfa (modified) (2 diffs)
• libcfa/src/iostream.cfa (modified) (3 diffs)
• src/ControlStruct/MultiLevelExit.cpp (modified) (10 diffs)
• tests/concurrency/waituntil/locks.cfa (modified) (1 diff)
• tests/exceptions/.expect/finally-error.txt (deleted)
• tests/exceptions/.expect/try-ctrl-flow.txt (added)
• tests/exceptions/finally-error.cfa (deleted)
• tests/exceptions/try-ctrl-flow.cfa (added)
• tests/io/.expect/manipulatorsInput.arm64.txt (modified) (1 diff)
• tests/io/.expect/manipulatorsInput.x64.txt (modified) (1 diff)
• tests/io/.expect/manipulatorsInput.x86.txt (modified) (1 diff)
• tests/io/.in/manipulatorsInput.txt (modified) (1 diff)
• tests/io/manipulatorsInput.cfa (modified) (1 diff)

libcfa/prelude/extras.c

@@ -3 +3 @@
 #include <uchar.h>                                      // char16_t, char32_t
 #include <wchar.h>                                      // wchar_t
-#include <stdlib.h>                                     // malloc, free, exit, atexit, abort
+#include <stdlib.h>                                     // malloc, free, getenv, exit, atexit, abort, printf
 #include <stdio.h>                                      // printf
+#include <string.h>                                     // strlen, strcmp, strncmp

libcfa/prelude/extras.regx2

@@ -1 +1 @@
 extern void \*malloc[^;]*;
 extern void free[^;]*;
+extern char \*getenv[^;]*;
 extern void exit[^;]*;
 extern int atexit[^;]*;
 extern void abort[^;]*;
 extern int printf[^;]*;
+int strcmp[^;]*;
+int strncmp[^;]*;
+size_t strlen[^;]*;

libcfa/src/clock.hfa

@@ -10 +10 @@
 // Created On       : Thu Apr 12 14:36:06 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Apr 18 08:12:16 2021
-// Update Count     : 28
+// Last Modified On : Sat Sep  9 14:07:17 2023
+// Update Count     : 30
 //
 
@@ -91 +91 @@
         // discontinuous jumps when the OS is not running the kernal thread. A duration is returned because the value is
         // relative and cannot be converted to real-time (wall-clock) time.
-        Duration processor() {                                                          // non-monotonic duration of kernel thread
+        Duration processor_cpu() {                                                      // non-monotonic duration of kernel thread
                 timespec ts;
                 clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
                 return (Duration){ ts };
-        } // processor
+        } // processor_cpu
 
         // Program CPU-time watch measures CPU time consumed by all processors (kernel threads) in the UNIX process.  This
         // watch is affected by discontinuous jumps when the OS is not running the kernel threads. A duration is returned
         // because the value is relative and cannot be converted to real-time (wall-clock) time.
-        Duration program() {                                                            // non-monotonic duration of program CPU
+        Duration program_cpu() {                                                        // non-monotonic duration of program CPU
                 timespec ts;
                 clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &ts );
                 return (Duration){ ts };
-        } // program
+        } // program_cpu
 
         // Monotonic duration from machine boot and including system suspension. This watch is unaffected by discontinuous

libcfa/src/concurrency/kernel/cluster.hfa

@@ -31 +31 @@
 
 // warn normally all ints
-#define warn_large_before warnf( !strict || old_avg < 33_000_000_000, "Suspiciously large previous average: %'llu (%llx), %'" PRId64 "ms \n", old_avg, old_avg, program()`ms )
-#define warn_large_after warnf( !strict || ret < 33_000_000_000, "Suspiciously large new average after %'" PRId64 "ms cputime: %'llu (%llx) from %'llu-%'llu (%'llu, %'llu) and %'llu\n", program()`ms, ret, ret, currtsc, intsc, new_val, new_val / 1000000, old_avg )
+#define warn_large_before warnf( !strict || old_avg < 33_000_000_000, "Suspiciously large previous average: %'llu (%llx), %'" PRId64 "ms \n", old_avg, old_avg, program_cpu()`ms )
+#define warn_large_after warnf( !strict || ret < 33_000_000_000, "Suspiciously large new average after %'" PRId64 "ms cputime: %'llu (%llx) from %'llu-%'llu (%'llu, %'llu) and %'llu\n", program_cpu()`ms, ret, ret, currtsc, intsc, new_val, new_val / 1000000, old_avg )
 
 // 8X linear factor is just 8 * x
@@ -42 +42 @@
 static inline __readyQ_avg_t __to_readyQ_avg(unsigned long long intsc) { if(unlikely(0 == intsc)) return 0.0; else return log2((__readyQ_avg_t)intsc); }
 
-#define warn_large_before warnf( !strict || old_avg < 35.0, "Suspiciously large previous average: %'lf, %'" PRId64 "ms \n", old_avg, program()`ms )
-#define warn_large_after warnf( !strict || ret < 35.3, "Suspiciously large new average after %'" PRId64 "ms cputime: %'lf from %'llu-%'llu (%'llu, %'llu) and %'lf\n", program()`ms, ret, currtsc, intsc, new_val, new_val / 1000000, old_avg ); \
+#define warn_large_before warnf( !strict || old_avg < 35.0, "Suspiciously large previous average: %'lf, %'" PRId64 "ms \n", old_avg, program_cpu()`ms )
+#define warn_large_after warnf( !strict || ret < 35.3, "Suspiciously large new average after %'" PRId64 "ms cputime: %'lf from %'llu-%'llu (%'llu, %'llu) and %'lf\n", program_cpu()`ms, ret, currtsc, intsc, new_val, new_val / 1000000, old_avg ); \
 verify(ret >= 0)
 

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 Aug  2 18:48:30 2023
-// Update Count     : 1614
+// Last Modified On : Mon Sep 11 11:21:10 2023
+// Update Count     : 1615
 //
 
@@ -691 +691 @@
         return stats;
 } // collectStats
+
+static inline void clearStats() {
+        lock( mgrLock );
+
+        // Zero the heap master and all active thread heaps.
+        HeapStatisticsCtor( heapMaster.stats );
+        for ( Heap * heap = heapMaster.heapManagersList; heap; heap = heap->nextHeapManager ) {
+                HeapStatisticsCtor( heap->stats );
+        } // for
+
+        unlock( mgrLock );
+} // clearStats
 #endif // __STATISTICS__
 
@@ -1556 +1568 @@
 
 
+        // Zero the heap master and all active thread heaps.
+        void malloc_stats_clear() {
+                #ifdef __STATISTICS__
+                clearStats();
+                #else
+                #define MALLOC_STATS_MSG "malloc_stats statistics disabled.\n"
+                if ( write( STDERR_FILENO, MALLOC_STATS_MSG, sizeof( MALLOC_STATS_MSG ) - 1 /* size includes '\0' */ ) == -1 ) {
+                        abort( "**** Error **** write failed in malloc_stats" );
+                } // if
+                #endif // __STATISTICS__
+        } // malloc_stats_clear
+
+
         // Changes the file descriptor where malloc_stats() writes statistics.
         int malloc_stats_fd( int fd __attribute__(( unused )) ) libcfa_public {

libcfa/src/heap.hfa

@@ -10 +10 @@
 // Created On       : Tue May 26 11:23:55 2020
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Oct  4 19:08:55 2022
-// Update Count     : 23
+// Last Modified On : Mon Sep 11 11:18:18 2023
+// Update Count     : 24
 // 
 
@@ -43 +43 @@
         size_t malloc_mmap_start();                                                     // crossover allocation size from sbrk to mmap
         size_t malloc_unfreed();                                                        // heap unfreed size (bytes)
+        void malloc_stats_clear();                                                      // clear heap statistics
 } // extern "C"
 

libcfa/src/iostream.cfa

@@ +1 @@
+
 //
 // Cforall Version 1.0.0 Copyright (C) 2015 University of Waterloo
@@ -976 +977 @@
                 if ( f.flags.ignore ) { fmtstr[1] = '*'; start += 1; }
                 // no maximum width necessary because text ignored => width is read width
-                if ( f.wd != -1 ) { start += sprintf( &fmtstr[start], "%d", f.wd ); }
+                if ( f.wd != -1 ) {
+                        // wd is buffer bytes available (for input chars + null terminator)
+                        // rwd is count of input chars
+                        int rwd = f.flags.rwd ? f.wd : (f.wd - 1);
+                        start += sprintf( &fmtstr[start], "%d", rwd );
+                }
 
                 if ( ! scanset ) {
@@ -993 +999 @@
                 } // if
 
-                int check = f.wd - 1;
+                int check = f.wd - 2;
                 if ( ! f.flags.rwd ) f.s[check] = '\0';                 // insert sentinel
                 len = fmt( is, fmtstr, f.s );

src/ControlStruct/MultiLevelExit.cpp

@@ -10 +10 @@
 // Created On       : Mon Nov  1 13:48:00 2021
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Sep  6 12:00:00 2023
-// Update Count     : 35
+// Last Modified On : Fri Sep  8 17:04:00 2023
+// Update Count     : 36
 //
 
@@ -27 +27 @@
 
 namespace {
+
+/// The return context is used to remember if returns are allowed and if
+/// not, why not. It is the nearest local control flow blocking construct.
+enum ReturnContext {
+        MayReturn,
+        InTryWithHandler,
+        InResumeHandler,
+        InTerminateHandler,
+        InFinally,
+};
 
 class Entry {
@@ -126 +136 @@
         void previsit( const TryStmt * );
         void postvisit( const TryStmt * );
+        void previsit( const CatchClause * );
         void previsit( const FinallyClause * );
 
@@ -134 +145 @@
         vector<Entry> enclosing_control_structures;
         Label break_label;
-        bool inFinally;
+        ReturnContext ret_context;
 
         template<typename LoopNode>
@@ -144 +155 @@
                 const list<ptr<Stmt>> & kids, bool caseClause );
 
+        void enterSealedContext( ReturnContext );
+
         template<typename UnaryPredicate>
         auto findEnclosingControlStructure( UnaryPredicate pred ) {
@@ -157 +170 @@
 MultiLevelExitCore::MultiLevelExitCore( const LabelToStmt & lt ) :
         target_table( lt ), break_label( CodeLocation(), "" ),
-        inFinally( false )
+        ret_context( ReturnContext::MayReturn )
 {}
 
@@ -488 +501 @@
 
 void MultiLevelExitCore::previsit( const ReturnStmt * stmt ) {
-        if ( inFinally ) {
-                SemanticError( stmt->location, "'return' may not appear in a finally clause" );
-        }
+        char const * context;
+        switch ( ret_context ) {
+        case ReturnContext::MayReturn:
+                return;
+        case ReturnContext::InTryWithHandler:
+                context = "try statement with a catch clause";
+                break;
+        case ReturnContext::InResumeHandler:
+                context = "catchResume clause";
+                break;
+        case ReturnContext::InTerminateHandler:
+                context = "catch clause";
+                break;
+        case ReturnContext::InFinally:
+                context = "finally clause";
+                break;
+        default:
+                assert(0);
+        }
+        SemanticError( stmt->location, toString( "'return' may not appear in a ", context ) );
 }
 
@@ -500 +530 @@
                 GuardAction([this](){ enclosing_control_structures.pop_back(); } );
         }
+
+        // Try statements/try blocks are only sealed with a termination handler.
+        for ( auto clause : stmt->handlers ) {
+                if ( ast::Terminate == clause->kind ) {
+                        return enterSealedContext( ReturnContext::InTryWithHandler );
+                }
+        }
 }
 
@@ -512 +549 @@
 }
 
+void MultiLevelExitCore::previsit( const CatchClause * clause ) {
+        ReturnContext context = ( ast::Terminate == clause->kind )
+                ? ReturnContext::InTerminateHandler : ReturnContext::InResumeHandler;
+        enterSealedContext( context );
+}
+
 void MultiLevelExitCore::previsit( const FinallyClause * ) {
-        GuardAction([this, old = std::move( enclosing_control_structures)](){ enclosing_control_structures = std::move(old); });
-        enclosing_control_structures = vector<Entry>();
-        GuardValue( inFinally ) = true;
+        enterSealedContext( ReturnContext::InFinally );
 }
 
@@ -617 +658 @@
 }
 
+void MultiLevelExitCore::enterSealedContext( ReturnContext enter_context ) {
+        GuardAction([this, old = std::move(enclosing_control_structures)](){ enclosing_control_structures = std::move(old); });
+        enclosing_control_structures = vector<Entry>();
+        GuardValue( ret_context ) = enter_context;
+}
+
 } // namespace
 

tests/concurrency/waituntil/locks.cfa

@@ -73 +73 @@
     printf("done\n");
 }
+

tests/io/.expect/manipulatorsInput.arm64.txt

@@ +1 @@
+pre1 "123456", canary ok
+pre2a "1234567", exception occurred, canary ok
+pre2b "89", canary ok
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx

tests/io/.expect/manipulatorsInput.x64.txt

@@ +1 @@
+pre1 "123456", canary ok
+pre2a "1234567", exception occurred, canary ok
+pre2b "89", canary ok
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx

tests/io/.expect/manipulatorsInput.x86.txt

@@ +1 @@
+pre1 "123456", canary ok
+pre2a "1234567", exception occurred, canary ok
+pre2b "89", canary ok
 1 yyyyyyyyyyyyyyyyyyyy
 2 abcxxx

tests/io/.in/manipulatorsInput.txt

@@ +1 @@
+123456
+123456789
 abc 
 abc 

tests/io/manipulatorsInput.cfa

@@ -15 +15 @@
 
 int main() {
+        {
+                // Upfront checks to ensure buffer safety.  Once these pass, the simpler `wdi(sizeof(s),s)`
+                // usage, as in the scanf alignment cases below, is justified.
+                struct {
+                        char buf[8];
+                        char canary;
+                } data;
+                static_assert( sizeof(data.buf) == 8 );
+                static_assert( &data.buf[8] == &data.canary );  // canary comes right after buf
+
+                void rep(const char* casename) {
+                        data.canary = 42;
+                        bool caught = false;
+                        try {
+                                sin | wdi( sizeof(data.buf), data.buf );
+                        } catch (cstring_length*) {
+                                caught = true;
+                        }
+                        printf( "%s \"%s\"", casename, data.buf );
+                        if ( caught ) {
+                                printf(", exception occurred");
+                        }
+                        if ( data.canary == 42 ) {
+                                printf(", canary ok");
+                        } else {
+                                printf(", canary overwritten to %d", data.canary);
+                        }
+                        printf("\n");
+                }
+
+                rep("pre1");
+                rep("pre2a");
+                rep("pre2b");
+                scanf("\n");  // next test does not start with %s so does not tolerate leading whitespace
+        }
         {
                 char s[] = "yyyyyyyyyyyyyyyyyyyy";