Changeset 13073be


Ignore:
Timestamp:
May 25, 2018, 1:37:34 PM (6 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc
Children:
8dbedfc
Parents:
a1a17a74
Message:

Fix atomic builtins in libcfa and prelude

Location:
src
Files:
3 added
12 edited

Legend:

Unmodified
Added
Removed

  • src/CodeGen/CodeGenerator.cc

    ra1a17a74 r13073be  
    119119
    120120        string CodeGenerator::mangleName( DeclarationWithType * decl ) {
    121                 if ( pretty ) return decl->get_name();
    122                 if ( decl->get_mangleName() != "" ) {
     121                // GCC builtins should always be printed unmangled
     122                if ( pretty || decl->linkage.is_gcc_builtin ) return decl->name;
     123                if ( decl->mangleName != "" ) {
    123124                        // need to incorporate scope level in order to differentiate names for destructors
    124125                        return decl->get_scopedMangleName();
    125126                } else {
    126                         return decl->get_name();
     127                        return decl->name;
    127128                } // if
    128129        }

  • src/Parser/LinkageSpec.h

    ra1a17a74 r13073be  
    2727                Overrideable = 1 << 2,
    2828                Builtin = 1 << 3,
     29                GccBuiltin = 1 << 4,
    2930
    30                 NoOfSpecs = 1 << 4,
     31                NoOfSpecs = 1 << 5,
    3132        };
    3233
    … …  
    3839                        bool is_overridable : 1;
    3940                        bool is_builtin : 1;
     41                        bool is_gcc_builtin : 1;
    4042                };
    4143                constexpr Spec( unsigned int val ) : val( val ) {}
    … …  
    6163        inline bool isOverridable( Spec spec ) { return spec.is_overridable; }
    6264        inline bool isBuiltin( Spec spec ) { return spec.is_builtin; }
     65        inline bool isGccBuiltin( Spec spec ) { return spec.is_gcc_builtin; }
    6366
    6467        // Pre-defined flag combinations:
    … …  
    7275        constexpr Spec const AutoGen = { Mangle | Generate | Overrideable };
    7376        // gcc internal
    74         constexpr Spec const Compiler = { Builtin };
     77        constexpr Spec const Compiler = { Mangle | Builtin | GccBuiltin };
    7578        // mangled builtins
    7679        constexpr Spec const BuiltinCFA = { Mangle | Generate | Builtin };

  • src/libcfa/bits/locks.h

    ra1a17a74 r13073be  
    3939#endif
    4040
    41 #if __SIZEOF_SIZE_T__ == 8
    42         #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_8( &(lock), 1 ) == 0
    43         #define __lock_release( lock ) __sync_lock_release_8( &(lock) );
    44 #elif __SIZEOF_SIZE_T__ == 4
    45         #define __lock_test_and_test_and_set( lock ) (lock) == 0 && __sync_lock_test_and_set_4( &(lock), 1 ) == 0
    46         #define __lock_release( lock ) __sync_lock_release_4( &(lock) );
    47 #else
    48         #error unsupported architecture
    49 #endif
    50 
    5141struct __spinlock_t {
    52         __ALIGN__ volatile size_t lock;
     42        // Wrap in struct to prevent false sharing with debug info
     43        struct {
     44                // Align lock on 128-bit boundary
     45                __ALIGN__ volatile _Bool lock;
     46        };
    5347        #ifdef __CFA_DEBUG__
     48                // previous function to acquire the lock
    5449                const char * prev_name;
     50                // previous thread to acquire the lock
    5551                void* prev_thrd;
    5652        #endif
    … …  
    7874        // Lock the spinlock, return false if already acquired
    7975        static inline _Bool try_lock  ( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
    80                 _Bool result = __lock_test_and_test_and_set( this.lock );
     76                _Bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
    8177                if( result ) {
    8278                        disable_interrupts();
    … …  
    9490
    9591                for ( unsigned int i = 1;; i += 1 ) {
    96                         if ( __lock_test_and_test_and_set( this.lock ) ) break;
     92                        if ( (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0) ) break;
    9793                        #ifndef NOEXPBACK
    9894                                // exponential spin
    … …  
    112108        }
    113109
    114         // // Lock the spinlock, yield if already acquired
    115         // static inline void lock_yield( __spinlock_t & this __cfaabi_dbg_ctx_param2 ) {
    116         //      for ( unsigned int i = 1;; i += 1 ) {
    117         //              if ( __lock_test_and_test_and_set( this.lock ) ) break;
    118         //              yield( i );
    119         //      }
    120         //      disable_interrupts();
    121         //      __cfaabi_dbg_debug_do(
    122         //              this.prev_name = caller;
    123         //              this.prev_thrd = this_thread;
    124         //      )
    125         // }
    126 
    127110        static inline void unlock( __spinlock_t & this ) {
    128111                enable_interrupts_noPoll();
    129                 __lock_release( this.lock );
     112                __atomic_clear( &this.lock, __ATOMIC_RELEASE );
    130113        }
    131114#endif

  • src/libcfa/concurrency/preemption.c

    ra1a17a74 r13073be  
    161161        void disable_interrupts() {
    162162                with( kernelTLS.preemption_state ) {
    163                         enabled = false;
     163                        static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
     164
     165                        // Set enabled flag to false
     166                        // should be atomic to avoid preemption in the middle of the operation.
     167                        // use memory order RELAXED since there is no inter-thread on this variable requirements
     168                        __atomic_store_n(&enabled, false, __ATOMIC_RELAXED);
     169
     170                        // Signal the compiler that a fence is needed but only for signal handlers
     171                        __atomic_signal_fence(__ATOMIC_ACQUIRE);
     172
    164173                        __attribute__((unused)) unsigned short new_val = disable_count + 1;
    165174                        disable_count = new_val;
    … …  
    171180        // If counter reaches 0, execute any pending CtxSwitch
    172181        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
    173                 processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add
    174                 thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic add
     182                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
     183                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic store
    175184
    176185                with( kernelTLS.preemption_state ){
    … …  
    181190                        // Check if we need to prempt the thread because an interrupt was missed
    182191                        if( prev == 1 ) {
    183                                 enabled = true;
     192                                static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
     193
     194                                // Set enabled flag to true
     195                                // should be atomic to avoid preemption in the middle of the operation.
     196                                // use memory order RELAXED since there is no inter-thread on this variable requirements
     197                                __atomic_store_n(&enabled, true, __ATOMIC_RELAXED);
     198
     199                                // Signal the compiler that a fence is needed but only for signal handlers
     200                                __atomic_signal_fence(__ATOMIC_RELEASE);
    184201                                if( proc->pending_preemption ) {
    185202                                        proc->pending_preemption = false;
    … …  
    200217                verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
    201218                if( prev == 1 ) {
    202                         kernelTLS.preemption_state.enabled = true;
     219                        static_assert(__atomic_always_lock_free(sizeof(kernelTLS.preemption_state.enabled), &kernelTLS.preemption_state.enabled), "Must be lock-free");
     220                        // Set enabled flag to true
     221                        // should be atomic to avoid preemption in the middle of the operation.
     222                        // use memory order RELAXED since there is no inter-thread on this variable requirements
     223                        __atomic_store_n(&kernelTLS.preemption_state.enabled, true, __ATOMIC_RELAXED);
     224
     225                        // Signal the compiler that a fence is needed but only for signal handlers
     226                        __atomic_signal_fence(__ATOMIC_RELEASE);
    203227                }
    204228        }

  • src/prelude/Makefile.am

    ra1a17a74 r13073be  
    3737# create forward declarations for gcc builtins
    3838gcc-builtins.cf : gcc-builtins.c prototypes.sed
    39         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
     39        ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -r -f prototypes.sed > $@
    4040
    41 gcc-builtins.c : builtins.def prototypes.awk
     41gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf
    4242        ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@
    4343

  • src/prelude/Makefile.in

    ra1a17a74 r13073be  
    506506# create forward declarations for gcc builtins
    507507gcc-builtins.cf : gcc-builtins.c prototypes.sed
    508         ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -f prototypes.sed > $@
    509 
    510 gcc-builtins.c : builtins.def prototypes.awk
     508        ${AM_V_GEN}@BACKEND_CC@ -E -P $< | sed -r -f prototypes.sed > $@
     509
     510gcc-builtins.c : builtins.def prototypes.awk sync-builtins.cf
    511511        ${AM_V_GEN}@BACKEND_CC@ -E prototypes.c | awk -f prototypes.awk > $@
    512512

  • src/prelude/builtins.def

    ra1a17a74 r13073be  
    190190
    191191/* Builtin used by implementation of Cilk Plus.  Most of these are decomposed
    192    by the compiler but a few are implemented in libcilkrts.  */ 
     192   by the compiler but a few are implemented in libcilkrts.  */
    193193#undef DEF_CILK_BUILTIN_STUB
    194194#define DEF_CILK_BUILTIN_STUB(ENUM, NAME) \
    … …  
    204204
    205205/* Builtin used by the implementation of libsanitizer. These
    206    functions are mapped to the actual implementation of the 
     206   functions are mapped to the actual implementation of the
    207207   libtsan library. */
    208208#undef DEF_SANITIZER_BUILTIN
    … …  
    217217#define DEF_CILKPLUS_BUILTIN(ENUM, NAME, TYPE, ATTRS)  \
    218218  DEF_BUILTIN (ENUM, NAME, BUILT_IN_NORMAL, BT_FN_INT_VAR, BT_LAST, \
    219                false, false, false, ATTRS, false, flag_cilkplus) 
     219               false, false, false, ATTRS, false, flag_cilkplus)
    220220
    221221/* Builtin used by the implementation of Pointer Bounds Checker.  */
    … …  
    927927DEF_GCC_BUILTIN (BUILT_IN_LINE, "LINE", BT_FN_INT, ATTR_NOTHROW_LEAF_LIST)
    928928
     929#if 0 //Ifdefed out because we hard-coded the proper overloadings of the atomic built-ins
    929930/* Synchronization Primitives.  */
    930931#include "sync-builtins.def"
    931932
    932 #if 0
    933933/* Offloading and Multi Processing builtins.  */
    934934#include "omp-builtins.def"

  • src/prelude/prelude.cf

    ra1a17a74 r13073be  
    458458signed long long int    ?=?( signed long long int &, signed long long int ),    ?=?( volatile signed long long int &, signed long long int );
    459459unsigned long long int  ?=?( unsigned long long int &, unsigned long long int ), ?=?( volatile unsigned long long int &, unsigned long long int );
     460__int128        ?=?( __int128 &, __int128 ),    ?=?( volatile __int128 &, __int128 );
    460461zero_t                  ?=?( zero_t &, zero_t );
    461462one_t                   ?=?( one_t &, one_t );

  • src/prelude/prototypes.awk

    ra1a17a74 r13073be  
    55# file "LICENCE" distributed with Cforall.
    66#
    7 # prototypes.awk -- 
     7# prototypes.awk --
    88#
    99# Author           : Peter A. Buhr
    … …  
    1212# Last Modified On : Tue Jul  5 14:32:52 2016
    1313# Update Count     : 32
    14 # 
     14#
    1515
    1616# http://llvm.org/svn/llvm-project/cfe/trunk/include/clang/Basic/Builtins.def
    … …  
    8383} # BEGIN
    8484
    85 /BT_FN/ { 
     85/BT_FN/ {
    8686    for (i = 1; i <= NF; i++) {
    8787      if( match($i, "BT_FN") != 0 ) {
    … …  
    116116
    117117      # generate function return type as macro
    118       for ( t = 0; t < N; t += 1 ) {                                    # find longest match 
     118      for ( t = 0; t < N; t += 1 ) {                                    # find longest match
    119119        type = types[t];
    120120        if ( index( prototype, type ) == 1 ) {          # found match
    … …  
    150150        # extras
    151151        printf( "\n#include \"builtins.def\"\n\n" );
     152        printf( "\n#include \"sync-builtins.cf\"\n\n" );
    152153        printf( "extern const char *__PRETTY_FUNCTION__;\n" );
    153154} # END

  • src/prelude/prototypes.sed

    ra1a17a74 r13073be  
    22/targetm/s/.*//                         #Remove targetm declarations
    33/__Unsupported/s/.*//                   #Remove Unsupported types declarations
    4 s/void (const char \*)0();//            #Remove void (const char \*)0();
     4s/void \(const char \*\)0\(\);//        #Remove void (const char \*)0();
    55s/\"//g                                         #Remove extraenous quotes in declarations
    6 /__builtin_/s/_ /_/g                    #Remove extraenous spaces in declarations
     6/__builtin_/s/_ /_/g                    #Remove extraenous spaces in declarations
     7
     8#Fix gcc overloading
     9# various sed rules for the gcc sync builtins which are overloaded
     10# kept here because they generate an acceptable approximate of the correct prototypes
     11
     12#/__sync_/s/_[0-9][0-9]*\(.*\)/\(\);/g  #hack since it will accept any parameters
     13#/__atomic_/s/_[0-9][0-9]*\(.*\)/\(\);/g        #hack since it will accept any parameters
     14
     15#/_16/s/void \*/__int128 \*/g
     16#/_8/s/void \*/long long int \*/g
     17#/_4/s/void \*/int \*/g
     18#/_2/s/void \*/short \*/g
     19#/_1/s/void \*/char \*/g
     20
     21#s/([a-zA-Z0-9_ ]+)\s+__sync([a-z_]+)_([0-9]+)\((.*)\);/\1 __sync\2\(\4\,...); \1 __sync\2_\3\(\4\,...);/
     22#s/([a-zA-Z0-9_ ]+)\s+__atomic([a-z_]+)_([0-9]+)\((.*)\);/\1 __atomic\2\(\4\); \1 __atomic\2_\3\(\4\);/

  • src/tests/Makefile.am

    ra1a17a74 r13073be  
    129129warnings/self-assignment: warnings/self-assignment.c @CFA_BINDIR@/@CFA_NAME@
    130130        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only
     131
     132#builtins
     133builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@
     134        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only

  • src/tests/Makefile.in

    ra1a17a74 r13073be  
    807807        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only
    808808
     809#builtins
     810builtins/sync: builtins/sync.c @CFA_BINDIR@/@CFA_NAME@
     811        ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} 2> ${@} -fsyntax-only
     812
    809813# Tell versions [3.59,3.63) of GNU make to not export all variables.
    810814# Otherwise a system limit (for SysV at least) may be exceeded.
Note: See TracChangeset for help on using the changeset viewer.