Changeset 9139540

Timestamp:

Nov 12, 2020, 11:04:23 PM (4 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

726b748

Parents:

10d609a (diff), 57ccff1 (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/preemption.cfa (modified) (15 diffs)
• src/Common/Stats/ResolveTime.cc (modified) (1 diff)
• tests/.expect/KRfunctions.arm64.txt (added)
• tests/.expect/attributes.arm64.txt (added)
• tests/.expect/bitmanip1.arm64.txt (added)
• tests/.expect/bitmanip2.arm64.txt (added)
• tests/.expect/bitmanip3.arm64.txt (added)
• tests/.expect/declarationSpecifier.arm64.txt (added)
• tests/.expect/extension.arm64.txt (added)
• tests/.expect/functions.arm64.txt (added)
• tests/.expect/gccExtensions.arm64.txt (added)
• tests/.expect/manipulatorsInput.arm64.txt (added)
• tests/.expect/manipulatorsOutput3.arm64.txt (added)
• tests/.expect/math4.arm64.txt (added)
• tests/errors/.expect/completeType.arm64.txt (added)
• tests/generator/suspend_then.cfa (modified) (1 diff)
• tests/pybin/tools.py (modified) (1 diff)
• tests/references.cfa (modified) (1 diff)
• tests/test.py (modified) (1 diff)
• tests/tuple/tupleAssign.cfa (modified) (2 diffs)

libcfa/src/concurrency/preemption.cfa

@@ -215 +215 @@
 // available.
 
+//-----------------------------------------------------------------------------
+// Some assembly required
+#define __cfaasm_label(label, when) when: asm volatile goto(".global __cfaasm_" #label "_" #when "\n" "__cfaasm_" #label "_" #when ":":::"memory":when)
+
 //----------
 // special case for preemption since used often
@@ -220 +224 @@
         // create a assembler label before
         // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_check_before:":::"memory");
+        __cfaasm_label(check, before);
 
         // access tls as normal
@@ -227 +231 @@
         // create a assembler label after
         // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_check_after:":::"memory");
+        __cfaasm_label(check, after);
         return enabled;
 }
@@ -246 +250 @@
 uintptr_t __cfatls_get( unsigned long int offset ) __attribute__((__noinline__)); //no inline to avoid problems
 uintptr_t __cfatls_get( unsigned long int offset ) {
-        // __cfaasm_get.before = ({ void * value; asm("movq $__cfaasm_get_before, %[v]\n\t" : [v]"=r"(value) ); value; });
-        // __cfaasm_get.after  = ({ void * value; asm("movq $__cfaasm_get_after , %[v]\n\t" : [v]"=r"(value) ); value; });
         // create a assembler label before
         // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_get_before:":::"memory");
+        __cfaasm_label(get, before);
 
         // access tls as normal (except for pointer arithmetic)
@@ -257 +259 @@
         // create a assembler label after
         // marked as clobber all to avoid movement
-        asm volatile("__cfaasm_get_after:":::"memory");
+        __cfaasm_label(get, after);
         return val;
 }
@@ -266 +268 @@
                 // create a assembler label before
                 // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_dsable_before:":::"memory");
+                __cfaasm_label(dsable, before);
 
                 with( __cfaabi_tls.preemption_state ) {
@@ -288 +290 @@
                 // create a assembler label after
                 // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_dsable_after:":::"memory");
+                __cfaasm_label(dsable, after);
+
         }
 
@@ -294 +297 @@
         // If counter reaches 0, execute any pending __cfactx_switch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                // create a assembler label before
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_enble_before:":::"memory");
-
-                processor   * proc = __cfaabi_tls.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
+                // Cache the processor now since interrupts can start happening after the atomic store
+                processor   * proc = __cfaabi_tls.this_processor;
                 /* paranoid */ verify( proc );
 
@@ -304 +304 @@
                         unsigned short prev = disable_count;
                         disable_count -= 1;
-                        verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
+
+                        // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
+                        /* paranoid */ verify( prev != 0u );
 
                         // Check if we need to prempt the thread because an interrupt was missed
                         if( prev == 1 ) {
                                 #if GCC_VERSION > 50000
-                                static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
+                                        static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
                                 #endif
 
@@ -328 +330 @@
                 // For debugging purposes : keep track of the last person to enable the interrupts
                 __cfaabi_dbg_debug_do( proc->last_enable = caller; )
-
-                // create a assembler label after
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_enble_after:":::"memory");
         }
 
@@ -337 +335 @@
         // Don't execute any pending __cfactx_switch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                // create a assembler label before
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_nopoll_before:":::"memory");
-
                 unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
                 __cfaabi_tls.preemption_state.disable_count -= 1;
-                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
+                // If this triggers someone is enabled already enabled interrupts
+                /* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
                 if( prev == 1 ) {
                         #if GCC_VERSION > 50000
-                        static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
+                                static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
                         #endif
                         // Set enabled flag to true
@@ -356 +351 @@
                         __atomic_signal_fence(__ATOMIC_RELEASE);
                 }
-
-                // create a assembler label after
-                // marked as clobber all to avoid movement
-                asm volatile("__cfaasm_nopoll_after:":::"memory");
-        }
-}
+        }
+}
+
+#undef __cfaasm_label
 
 // sigprocmask wrapper : unblock a single signal
@@ -446 +439 @@
 #elif defined( __aarch64__ )
         #ifdef __PIC__
-                #define RELOC_TAG "@PLT"
-        #else
-                #define RELOC_TAG ""
-        #endif
-        #define __cfaasm_label( label ) \
+                // Note that this works only for gcc
+                #define __cfaasm_label( label ) static struct asm_region label = \
                 ({ \
                         struct asm_region region; \
                         asm( \
-                                "mov %[vb], __cfaasm_" #label "_before@GOTPCREL(%%rip)"  "\n\t" \
-                                "mov %[va], __cfaasm_" #label "_after@GOTPCREL(%%rip)"   "\n\t" \
+                                "adrp %[vb], _GLOBAL_OFFSET_TABLE_"                              "\n\t" \
+                                "ldr  %[vb], [%[vb], #:gotpage_lo15:__cfaasm_" #label "_before]" "\n\t" \
+                                "adrp %[va], _GLOBAL_OFFSET_TABLE_"                              "\n\t" \
+                                "ldr  %[va], [%[va], #:gotpage_lo15:__cfaasm_" #label "_after]"  "\n\t" \
                                  : [vb]"=r"(region.before), [va]"=r"(region.after) \
                         ); \
                         region; \
                 });
+        #else
+                #error this is not the right thing to do
+                /*
+                #define __cfaasm_label( label ) static struct asm_region label = \
+                ({ \
+                        struct asm_region region; \
+                        asm( \
+                                "adrp %[vb], __cfaasm_" #label "_before"              "\n\t" \
+                                "add  %[vb], %[vb], :lo12:__cfaasm_" #label "_before" "\n\t" \
+                                "adrp %[va], :got:__cfaasm_" #label "_after"          "\n\t" \
+                                "add  %[va], %[va], :lo12:__cfaasm_" #label "_after"  "\n\t" \
+                                 : [vb]"=r"(region.before), [va]"=r"(region.after) \
+                        ); \
+                        region; \
+                });
+                */
+        #endif
 #else
         #error unknown hardware architecture
@@ -473 +482 @@
         __cfaasm_label( check  );
         __cfaasm_label( dsable );
-        __cfaasm_label( enble );
-        __cfaasm_label( nopoll );
 
         // Check if preemption is safe
@@ -481 +488 @@
         if( __cfaasm_in( ip, check  ) ) { ready = false; goto EXIT; };
         if( __cfaasm_in( ip, dsable ) ) { ready = false; goto EXIT; };
-        if( __cfaasm_in( ip, enble  ) ) { ready = false; goto EXIT; };
-        if( __cfaasm_in( ip, nopoll ) ) { ready = false; goto EXIT; };
         if( !__cfaabi_tls.preemption_state.enabled) { ready = false; goto EXIT; };
         if( __cfaabi_tls.preemption_state.in_progress ) { ready = false; goto EXIT; };

src/Common/Stats/ResolveTime.cc

@@ -27 +27 @@
         namespace ResolveTime {
                 static inline long long rdtscl(void) {
-                        unsigned int lo, hi;
-                        __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
-                        return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+                        #if defined( __i386 ) || defined( __x86_64 )
+                                unsigned int lo, hi;
+                                __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
+                                return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
+                        #elif defined( __aarch64__ )
+                                int64_t value;
+                                asm volatile("mrs %0, cntvct_el0" : "=r"(value));
+                                return value;
+                        #else
+                                #error unknown hardware architecture
+                        #endif
                 }
 

tests/generator/suspend_then.cfa

@@ -40 +40 @@
         Fibonacci f1, f2;
         for ( 10 ) {                                                            // print N Fibonacci values
-                sout | next( f1 ) | next( f2 );
+                int v1 = next( f1 );
+                int v2 = next( f2 );
+                sout | v1 | v2;
         } // for
 }

tests/pybin/tools.py

@@ -73 +73 @@
                                         )
 
-                                        return proc.returncode, out.decode("utf-8") if out else None
+                                        return proc.returncode, out.decode("latin-1") if out else None
                                 except subprocess.TimeoutExpired:
                                         if settings.timeout2gdb:

tests/references.cfa

@@ -124 +124 @@
                 int *p = &a;
                 asm (
-                        "incl %[p]\n\t"
-                        : [p] "+m" (*p)
+                        #if defined( __i386 ) || defined( __x86_64 )
+                                "incl %[p]\n\t"
+                                : [p] "+m" (*p)
+                        #elif defined( __aarch64__ )
+                                "ldr     w1, %[p]\n\t"
+                                "add     w1, w1, 1\n\t"
+                                "str     w1, %[p]\n\t"
+                                : [p] "+m" (*p) ::"w1"
+                        #endif
                 );
                 printf("%d\n", a);

tests/test.py

@@ -99 +99 @@
 
                                         # print a warning if it users didn't ask for a specific architecture
-                                        if not options.arch:
+                                        found_arch = [f.arch for f in found if f.arch]
+                                        if found_arch and not options.arch:
                                                 print('WARNING: "%s", test has architecture specific expected files but --arch was not specified, regenerating only for current host' % testname, file=sys.stderr)
 
 
                                         # print a warning if it users didn't ask for a specific ast version
-                                        if not options.ast:
+                                        found_astv = [f.astv for f in found if f.astv]
+                                        if found_astv and not options.ast:
                                                 print('WARNING: "%s", test has ast version specific expected files but --ast was not specified, regenerating only for current ast' % testname, file=sys.stderr)
 

tests/tuple/tupleAssign.cfa

@@ -44 +44 @@
                 double d = 0.0;
                 int i = 0;
-                char c = '\0';
+                signed char c = '\0';
                 struct X {
                         int z;
@@ -55 +55 @@
                 [t, x, d, i, c, x] = (double)94.12;
                 printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, (int)c, t );
-                sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]";
+                sout | "d=" | d | "i=" | i | "c=" | (char)c | ' ' | "t=[" | t | "]";
                 [x, c, i, d, x, t] = (double)-94.12;
                 printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, c, t );
-                sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]";
+                sout | "d=" | d | "i=" | i | "c=" | (char)c | ' ' | "t=[" | t | "]";
         }
 }