Changeset 9139540


Ignore:
Timestamp:
Nov 12, 2020, 11:04:23 PM (11 months ago)
Author:
Peter A. Buhr <pabuhr@…>
Branches:
arm-eh, jacob/cs343-translation, master, new-ast-unique-expr
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:
13 added
7 edited

Legend:

Unmodified
Added
Removed
  • libcfa/src/concurrency/preemption.cfa

    r10d609a r9139540  
    215215// available.
    216216
     217//-----------------------------------------------------------------------------
     218// Some assembly required
     219#define __cfaasm_label(label, when) when: asm volatile goto(".global __cfaasm_" #label "_" #when "\n" "__cfaasm_" #label "_" #when ":":::"memory":when)
     220
    217221//----------
    218222// special case for preemption since used often
     
    220224        // create a assembler label before
    221225        // marked as clobber all to avoid movement
    222         asm volatile("__cfaasm_check_before:":::"memory");
     226        __cfaasm_label(check, before);
    223227
    224228        // access tls as normal
     
    227231        // create a assembler label after
    228232        // marked as clobber all to avoid movement
    229         asm volatile("__cfaasm_check_after:":::"memory");
     233        __cfaasm_label(check, after);
    230234        return enabled;
    231235}
     
    246250uintptr_t __cfatls_get( unsigned long int offset ) __attribute__((__noinline__)); //no inline to avoid problems
    247251uintptr_t __cfatls_get( unsigned long int offset ) {
    248         // __cfaasm_get.before = ({ void * value; asm("movq $__cfaasm_get_before, %[v]\n\t" : [v]"=r"(value) ); value; });
    249         // __cfaasm_get.after  = ({ void * value; asm("movq $__cfaasm_get_after , %[v]\n\t" : [v]"=r"(value) ); value; });
    250252        // create a assembler label before
    251253        // marked as clobber all to avoid movement
    252         asm volatile("__cfaasm_get_before:":::"memory");
     254        __cfaasm_label(get, before);
    253255
    254256        // access tls as normal (except for pointer arithmetic)
     
    257259        // create a assembler label after
    258260        // marked as clobber all to avoid movement
    259         asm volatile("__cfaasm_get_after:":::"memory");
     261        __cfaasm_label(get, after);
    260262        return val;
    261263}
     
    266268                // create a assembler label before
    267269                // marked as clobber all to avoid movement
    268                 asm volatile("__cfaasm_dsable_before:":::"memory");
     270                __cfaasm_label(dsable, before);
    269271
    270272                with( __cfaabi_tls.preemption_state ) {
     
    288290                // create a assembler label after
    289291                // marked as clobber all to avoid movement
    290                 asm volatile("__cfaasm_dsable_after:":::"memory");
     292                __cfaasm_label(dsable, after);
     293
    291294        }
    292295
     
    294297        // If counter reaches 0, execute any pending __cfactx_switch
    295298        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
    296                 // create a assembler label before
    297                 // marked as clobber all to avoid movement
    298                 asm volatile("__cfaasm_enble_before:":::"memory");
    299 
    300                 processor   * proc = __cfaabi_tls.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
     299                // Cache the processor now since interrupts can start happening after the atomic store
     300                processor   * proc = __cfaabi_tls.this_processor;
    301301                /* paranoid */ verify( proc );
    302302
     
    304304                        unsigned short prev = disable_count;
    305305                        disable_count -= 1;
    306                         verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
     306
     307                        // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
     308                        /* paranoid */ verify( prev != 0u );
    307309
    308310                        // Check if we need to prempt the thread because an interrupt was missed
    309311                        if( prev == 1 ) {
    310312                                #if GCC_VERSION > 50000
    311                                 static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
     313                                        static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
    312314                                #endif
    313315
     
    328330                // For debugging purposes : keep track of the last person to enable the interrupts
    329331                __cfaabi_dbg_debug_do( proc->last_enable = caller; )
    330 
    331                 // create a assembler label after
    332                 // marked as clobber all to avoid movement
    333                 asm volatile("__cfaasm_enble_after:":::"memory");
    334332        }
    335333
     
    337335        // Don't execute any pending __cfactx_switch even if counter reaches 0
    338336        void enable_interrupts_noPoll() {
    339                 // create a assembler label before
    340                 // marked as clobber all to avoid movement
    341                 asm volatile("__cfaasm_nopoll_before:":::"memory");
    342 
    343337                unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
    344338                __cfaabi_tls.preemption_state.disable_count -= 1;
    345                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
     339                // If this triggers someone is enabled already enabled interrupts
     340                /* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
    346341                if( prev == 1 ) {
    347342                        #if GCC_VERSION > 50000
    348                         static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
     343                                static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
    349344                        #endif
    350345                        // Set enabled flag to true
     
    356351                        __atomic_signal_fence(__ATOMIC_RELEASE);
    357352                }
    358 
    359                 // create a assembler label after
    360                 // marked as clobber all to avoid movement
    361                 asm volatile("__cfaasm_nopoll_after:":::"memory");
    362         }
    363 }
     353        }
     354}
     355
     356#undef __cfaasm_label
    364357
    365358// sigprocmask wrapper : unblock a single signal
     
    446439#elif defined( __aarch64__ )
    447440        #ifdef __PIC__
    448                 #define RELOC_TAG "@PLT"
    449         #else
    450                 #define RELOC_TAG ""
    451         #endif
    452         #define __cfaasm_label( label ) \
     441                // Note that this works only for gcc
     442                #define __cfaasm_label( label ) static struct asm_region label = \
    453443                ({ \
    454444                        struct asm_region region; \
    455445                        asm( \
    456                                 "mov %[vb], __cfaasm_" #label "_before@GOTPCREL(%%rip)"  "\n\t" \
    457                                 "mov %[va], __cfaasm_" #label "_after@GOTPCREL(%%rip)"   "\n\t" \
     446                                "adrp %[vb], _GLOBAL_OFFSET_TABLE_"                              "\n\t" \
     447                                "ldr  %[vb], [%[vb], #:gotpage_lo15:__cfaasm_" #label "_before]" "\n\t" \
     448                                "adrp %[va], _GLOBAL_OFFSET_TABLE_"                              "\n\t" \
     449                                "ldr  %[va], [%[va], #:gotpage_lo15:__cfaasm_" #label "_after]"  "\n\t" \
    458450                                 : [vb]"=r"(region.before), [va]"=r"(region.after) \
    459451                        ); \
    460452                        region; \
    461453                });
     454        #else
     455                #error this is not the right thing to do
     456                /*
     457                #define __cfaasm_label( label ) static struct asm_region label = \
     458                ({ \
     459                        struct asm_region region; \
     460                        asm( \
     461                                "adrp %[vb], __cfaasm_" #label "_before"              "\n\t" \
     462                                "add  %[vb], %[vb], :lo12:__cfaasm_" #label "_before" "\n\t" \
     463                                "adrp %[va], :got:__cfaasm_" #label "_after"          "\n\t" \
     464                                "add  %[va], %[va], :lo12:__cfaasm_" #label "_after"  "\n\t" \
     465                                 : [vb]"=r"(region.before), [va]"=r"(region.after) \
     466                        ); \
     467                        region; \
     468                });
     469                */
     470        #endif
    462471#else
    463472        #error unknown hardware architecture
     
    473482        __cfaasm_label( check  );
    474483        __cfaasm_label( dsable );
    475         __cfaasm_label( enble );
    476         __cfaasm_label( nopoll );
    477484
    478485        // Check if preemption is safe
     
    481488        if( __cfaasm_in( ip, check  ) ) { ready = false; goto EXIT; };
    482489        if( __cfaasm_in( ip, dsable ) ) { ready = false; goto EXIT; };
    483         if( __cfaasm_in( ip, enble  ) ) { ready = false; goto EXIT; };
    484         if( __cfaasm_in( ip, nopoll ) ) { ready = false; goto EXIT; };
    485490        if( !__cfaabi_tls.preemption_state.enabled) { ready = false; goto EXIT; };
    486491        if( __cfaabi_tls.preemption_state.in_progress ) { ready = false; goto EXIT; };
  • src/Common/Stats/ResolveTime.cc

    r10d609a r9139540  
    2727        namespace ResolveTime {
    2828                static inline long long rdtscl(void) {
    29                         unsigned int lo, hi;
    30                         __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
    31                         return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
     29                        #if defined( __i386 ) || defined( __x86_64 )
     30                                unsigned int lo, hi;
     31                                __asm__ __volatile__ ("rdtsc" : "=a"(lo), "=d"(hi));
     32                                return ( (unsigned long long)lo)|( ((unsigned long long)hi)<<32 );
     33                        #elif defined( __aarch64__ )
     34                                int64_t value;
     35                                asm volatile("mrs %0, cntvct_el0" : "=r"(value));
     36                                return value;
     37                        #else
     38                                #error unknown hardware architecture
     39                        #endif
    3240                }
    3341
  • tests/generator/suspend_then.cfa

    r10d609a r9139540  
    4040        Fibonacci f1, f2;
    4141        for ( 10 ) {                                                            // print N Fibonacci values
    42                 sout | next( f1 ) | next( f2 );
     42                int v1 = next( f1 );
     43                int v2 = next( f2 );
     44                sout | v1 | v2;
    4345        } // for
    4446}
  • tests/pybin/tools.py

    r10d609a r9139540  
    7373                                        )
    7474
    75                                         return proc.returncode, out.decode("utf-8") if out else None
     75                                        return proc.returncode, out.decode("latin-1") if out else None
    7676                                except subprocess.TimeoutExpired:
    7777                                        if settings.timeout2gdb:
  • tests/references.cfa

    r10d609a r9139540  
    124124                int *p = &a;
    125125                asm (
    126                         "incl %[p]\n\t"
    127                         : [p] "+m" (*p)
     126                        #if defined( __i386 ) || defined( __x86_64 )
     127                                "incl %[p]\n\t"
     128                                : [p] "+m" (*p)
     129                        #elif defined( __aarch64__ )
     130                                "ldr     w1, %[p]\n\t"
     131                                "add     w1, w1, 1\n\t"
     132                                "str     w1, %[p]\n\t"
     133                                : [p] "+m" (*p) ::"w1"
     134                        #endif
    128135                );
    129136                printf("%d\n", a);
  • tests/test.py

    r10d609a r9139540  
    9999
    100100                                        # print a warning if it users didn't ask for a specific architecture
    101                                         if not options.arch:
     101                                        found_arch = [f.arch for f in found if f.arch]
     102                                        if found_arch and not options.arch:
    102103                                                print('WARNING: "%s", test has architecture specific expected files but --arch was not specified, regenerating only for current host' % testname, file=sys.stderr)
    103104
    104105
    105106                                        # print a warning if it users didn't ask for a specific ast version
    106                                         if not options.ast:
     107                                        found_astv = [f.astv for f in found if f.astv]
     108                                        if found_astv and not options.ast:
    107109                                                print('WARNING: "%s", test has ast version specific expected files but --ast was not specified, regenerating only for current ast' % testname, file=sys.stderr)
    108110
  • tests/tuple/tupleAssign.cfa

    r10d609a r9139540  
    4444                double d = 0.0;
    4545                int i = 0;
    46                 char c = '\0';
     46                signed char c = '\0';
    4747                struct X {
    4848                        int z;
     
    5555                [t, x, d, i, c, x] = (double)94.12;
    5656                printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, (int)c, t );
    57                 sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]";
     57                sout | "d=" | d | "i=" | i | "c=" | (char)c | ' ' | "t=[" | t | "]";
    5858                [x, c, i, d, x, t] = (double)-94.12;
    5959                printf( "d=%lg i=%d c=%c t=[%d, %lg, %d]\n", d, i, c, t );
    60                 sout | "d=" | d | "i=" | i | "c=" | c | ' ' | "t=[" | t | "]";
     60                sout | "d=" | d | "i=" | i | "c=" | (char)c | ' ' | "t=[" | t | "]";
    6161        }
    6262}
Note: See TracChangeset for help on using the changeset viewer.