Changeset 933f32f for libcfa/prelude


Ignore:
Timestamp:
May 24, 2019, 10:19:41 AM (3 years ago)
Author:
Thierry Delisle <tdelisle@…>
Branches:
arm-eh, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr
Children:
d908563
Parents:
6a9d4b4 (diff), 292642a (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' into cleanup-dtors

Location:
libcfa/prelude
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • libcfa/prelude/builtins.c

    r6a9d4b4 r933f32f  
    1010// Created On       : Fri Jul 21 16:21:03 2017
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Aug  5 21:40:38 2018
    13 // Update Count     : 20
     12// Last Modified On : Tue Mar 26 23:10:36 2019
     13// Update Count     : 95
    1414//
    1515
     
    4242typedef unsigned long long __cfaabi_abi_exception_type_t;
    4343
     44#include <limits.h>                                                                             // CHAR_BIT
    4445#include "../src/virtual.h"
    4546#include "../src/exception.h"
     
    5051// increment/decrement unification
    5152
    52 static inline forall( dtype T | { T& ?+=?( T&, one_t ); } )
    53 T& ++? ( T& x ) { return x += 1; }
     53static inline {
     54        forall( dtype DT | { DT & ?+=?( DT &, one_t ); } )
     55        DT & ++?( DT & x ) { return x += 1; }
    5456
    55 static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } )
    56 T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; }
     57        forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } )
     58        DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; }
    5759
    58 static inline forall( dtype T | { T& ?-=?( T&, one_t ); } )
    59 T& --? ( T& x ) { return x -= 1; }
     60        forall( dtype DT | { DT & ?-=?( DT &, one_t ); } )
     61        DT & --?( DT & x ) { return x -= 1; }
    6062
    61 static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } )
    62 T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; }
     63        forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } )
     64        DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; }
     65} // distribution
     66
     67// universal typed pointer constant
     68// Compiler issue: there is a problem with anonymous types that do not have a size.
     69static inline forall( dtype DT | sized(DT) ) DT * intptr( uintptr_t addr ) { return (DT *)addr; }
    6370
    6471// exponentiation operator implementation
     
    7380} // extern "C"
    7481
    75 static inline float ?\?( float x, float y ) { return powf( x, y ); }
    76 static inline double ?\?( double x, double y ) { return pow( x, y ); }
    77 static inline long double ?\?( long double x, long double y ) { return powl( x, y ); }
    78 static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
    79 static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
    80 static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
     82static inline {
     83        float ?\?( float x, float y ) { return powf( x, y ); }
     84        double ?\?( double x, double y ) { return pow( x, y ); }
     85        long double ?\?( long double x, long double y ) { return powl( x, y ); }
     86        float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); }
     87        double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); }
     88        long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); }
     89} // distribution
    8190
    82 static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent
    83         if ( y == 0 ) return 1;                                                         // base case
    84         if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
    85         typeof( ep ) op = 1;                                                            // accumulate odd product
    86         for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
    87                 if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
    88                 ep *= ep;
    89         } // for
    90         return ep * op;
    91 } // ?\?
     91#define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1
     92#define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1)
     93#define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0
    9294
    93 static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } )
    94 T ?\?( T ep, unsigned long int y ) {
    95         if ( y == 0 ) return 1;
    96         T op = 1;
    97         for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
    98                 if ( (y & 1) == 1 ) op = op * ep;                               // odd ?
    99                 ep = ep * ep;
    100         } // for
    101         return ep * op;
    102 } // ?\?
     95#define __CFA_EXP__() \
     96        if ( y == 0 ) return 1;                                                         /* convention */ \
     97        __CFA_BASE_COMP_1__();                                                          /* base case */ \
     98        __CFA_BASE_COMP_2__();                                                          /* special case, positive shifting for integral types */ \
     99        __CFA_EXP_OVERFLOW__();                                                         /* immediate overflow, negative exponent > 2^size-1 */ \
     100        typeof(ep) op = 1;                                                                      /* accumulate odd product */ \
     101        for ( ; y > 1; y >>= 1 ) {                                                      /* squaring exponentiation, O(log2 y) */ \
     102                if ( (y & 1) == 1 ) op = op * ep;                               /* odd ? */ \
     103                ep = ep * ep; \
     104        } \
     105        return ep * op
    103106
    104 // unsigned computation may be faster and larger
    105 static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent
    106         if ( y == 0 ) return 1;                                                         // base case
    107         if ( ep == 2 ) return ep << (y - 1);                            // special case, positive shifting only
    108         typeof( ep ) op = 1;                                                            // accumulate odd product
    109         for ( ; y > 1; y >>= 1 ) {                                                      // squaring exponentiation, O(log2 y)
    110                 if ( (y & 1) == 1 ) op *= ep;                                   // odd ?
    111                 ep *= ep;
    112         } // for
    113         return ep * op;
    114 } // ?\?
     107static inline {
     108        long int ?\?( int ep, unsigned int y ) { __CFA_EXP__(); }
     109        long int ?\?( long int ep, unsigned long int y ) { __CFA_EXP__(); }
     110        // unsigned computation may be faster and larger
     111        unsigned long int ?\?( unsigned int ep, unsigned int y ) { __CFA_EXP__(); }
     112        unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { __CFA_EXP__(); }
     113} // distribution
    115114
    116 static inline double ?\?( long int x, signed long int y ) {     // allow negative exponent
    117         if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
    118         else return 1.0 / x \ (unsigned int)(-y);
    119 } // ?\?
     115#undef __CFA_BASE_COMP_1__
     116#undef __CFA_BASE_COMP_2__
     117#undef __CFA_EXP_OVERFLOW__
     118#define __CFA_BASE_COMP_1__()
     119#define __CFA_BASE_COMP_2__()
     120#define __CFA_EXP_OVERFLOW__()
    120121
    121 // FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither
    122 // defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify
    123 // X as a type that casts to double, yet it doesn't make sense to write functions with that type
    124 // signature where X is double.
     122static inline forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) {
     123        OT ?\?( OT ep, unsigned int y ) { __CFA_EXP__(); }
     124        OT ?\?( OT ep, unsigned long int y ) { __CFA_EXP__(); }
     125} // distribution
    125126
    126 // static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } )
    127 // double ?\?( T x, signed long int y ) {
    128 //     if ( y >=  0 ) return (double)(x \ (unsigned long int)y);
    129 //     else return 1.0 / x \ (unsigned long int)(-y);
    130 // } // ?\?
     127#undef __CFA_BASE_COMP_1__
     128#undef __CFA_BASE_COMP_2__
     129#undef __CFA_EXP_OVERFLOW__
    131130
    132 static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
    133 static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
    134 static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
    135 static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
     131static inline {
     132        long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; }
     133        unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; }
     134        int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; }
     135        unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; }
     136} // distribution
    136137
    137138// Local Variables: //
  • libcfa/prelude/extras.c

    r6a9d4b4 r933f32f  
    1 #include <stddef.h>                                     // size_t, ptrdiff_t
     1#include <stddef.h>                                     // size_t, ptrdiff_t, intptr_t, uintptr_t
    22#include <stdint.h>                                     // intX_t, uintX_t, where X is 8, 16, 32, 64
    33#include <uchar.h>                                      // char16_t, char32_t
  • libcfa/prelude/extras.regx

    r6a9d4b4 r933f32f  
    11typedef.* size_t;
    22typedef.* ptrdiff_t;
     3typedef.* intptr_t;
     4typedef.* uintptr_t;
    35typedef.* __int8_t;
    46typedef.* __int16_t;
  • libcfa/prelude/prelude-gen.cc

    r6a9d4b4 r933f32f  
     1//
     2// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
     3//
     4// The contents of this file are covered under the licence agreement in the
     5// file "LICENCE" distributed with Cforall.
     6//
     7// prelude-gen.cc --
     8//
     9// Author           : Rob Schluntz and Thierry Delisle
     10// Created On       : Sat Feb 16 08:44:58 2019
     11// Last Modified By : Peter A. Buhr
     12// Last Modified On : Tue Apr  2 17:18:24 2019
     13// Update Count     : 37
     14//
     15
    116#include <algorithm>
    217#include <array>
     
    1126        bool hasComparison;
    1227} basicTypes[] = {
    13         // { "char"                  , false, true , },
    14         // { "signed char"           , false, true , },
    15         // { "unsigned char"         , false, true , },
     28        { "char"                  , false, true , },
     29        { "signed char"           , false, true , },
     30        { "unsigned char"         , false, true , },
    1631        { "signed short"          , false, true , },
    1732        { "unsigned short"        , false, true , },
     
    3449#if defined(__i386__) || defined(__ia64__) || defined(__x86_64__)
    3550        { "__float80"             , true , true , },
    36         { "_Float128"             , true , true , },
     51        { "__float128"            , true , true , },
    3752#endif
    3853};
     
    103118        { "?!=?", false, "signed int", Normal, "" },
    104119        { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ???
    105         { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
     120//      { "*?", false, "&", Normal, " | sized(DT)" }, // & ???
     121        { "*?", false, "&", Normal, "" }, // & ???
    106122
    107123        { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" },
     
    150166        cout << endl;
    151167
    152         cout << "signed int ?==?( zero_t, zero_t ),                                                     ?!=?( zero_t, zero_t );" << endl;
    153         cout << "signed int ?==?( one_t, one_t ),                                                       ?!=?( one_t, one_t );" << endl;
    154         cout << "signed int ?==?( _Bool, _Bool ),                                                       ?!=?( _Bool, _Bool );" << endl;
    155         cout << "signed int     !?( _Bool );" << endl;
     168        cout << "signed int ?==?( zero_t, zero_t ),     ?!=?( zero_t, zero_t );" << endl;
     169        cout << "signed int ?==?( one_t, one_t ),       ?!=?( one_t, one_t );" << endl;
     170        cout << "signed int ?==?( _Bool, _Bool ),       ?!=?( _Bool, _Bool );" << endl;
     171        cout << "signed int !?( _Bool );" << endl;
    156172
    157173        for (auto op : arithmeticOperators) {
     
    188204        cout << "// Arithmetic Constructors //" << endl;
    189205        cout << "/////////////////////////////" << endl;
     206        cout << endl;
     207
    190208        auto otype = [](const std::string & type, bool do_volatile = false) {
    191                 cout << "void \t?{} ( " << type << " & );" << endl;
    192                 cout << "void \t?{} ( " << type << " &, " << type << " );" << endl;
    193                 cout << type << " \t?=? ( " << type << " &, " << type << " )";
    194                 if( do_volatile ) {
    195                         cout << ", \t?=?( volatile " << type << " &, " << type << " )";
     209                cout << "void ?{} (" << type << " &);" << endl;
     210                cout << "void ?{} (" << type << " &, " << type << ");" << endl;
     211                cout << type << " ?=? (" << type << " &, " << type << ")";
     212                if ( do_volatile ) {
     213                        cout << ", ?=?(volatile " << type << " &, " << type << ")";
    196214                }
    197215                cout << ";" << endl;
    198                 cout << "void \t^?{}( " << type << " & );" << endl;
     216                cout << "void ^?{}( " << type << " & );" << endl;
    199217        };
    200218
    201219        otype("zero_t");
     220        cout << endl;
    202221        otype("one_t");
     222        cout << endl;
    203223        otype("_Bool", true);
    204         otype("char", true);
    205         otype("signed char", true);
    206         otype("unsigned char", true);
     224        cout << endl;
    207225
    208226        for (auto type : basicTypes) {
    209                 cout << "void  ?{}(" << type.name << " &);" << endl;
    210                 cout << "void  ?{}(" << type.name << " &, " << type.name << ");" << endl;
     227                cout << "void ?{}(" << type.name << " &);" << endl;
     228                cout << "void ?{}(" << type.name << " &, " << type.name << ");" << endl;
     229                cout << "void ?{}(" << type.name << " &, zero_t);" << endl;
     230                cout << "void ?{}(" << type.name << " &, one_t);" << endl;
    211231                cout << "void ^?{}(" << type.name << " &);" << endl;
    212232                cout << endl;
     
    217237        cout << "// Pointer Constructors //" << endl;
    218238        cout << "//////////////////////////" << endl;
    219         cout << "forall(ftype FT) void  ?{}( FT *&, FT * );" << endl;
    220         cout << "forall(ftype FT) void  ?{}( FT * volatile &, FT * );" << endl;
     239        cout << endl;
     240
     241        cout << "forall(ftype FT) void ?{}( FT *&, FT * );" << endl;
     242        cout << "forall(ftype FT) void ?{}( FT * volatile &, FT * );" << endl;
    221243
    222244        // generate qualifiers
     
    242264                for (auto cvq : qualifiersPair) {
    243265                        for (auto is_vol : { "        ", "volatile" }) {
    244                                 cout << "forall(dtype DT) void  ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
     266                                cout << "forall(dtype DT) void ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl;
    245267                        }
    246268                }
    247269                for (auto cvq : qualifiersSingle) {
    248270                        for (auto is_vol : { "        ", "volatile" }) {
    249                                 cout << "forall(dtype DT) void  ?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
     271                                cout << "forall(dtype DT) void ?{}(" << cvq << type << " * " << is_vol << " &);" << endl;
    250272                        }
    251273                        for (auto is_vol : { "        ", "volatile" }) {
     
    269291        cout << "forall(ftype FT) FT *                  ?=?( FT *          &, zero_t );" << endl;
    270292        cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, zero_t );" << endl;
    271         cout << "forall( ftype FT ) void        ?{}( FT *          & );" << endl;
    272         cout << "forall( ftype FT ) void        ^?{}( FT *         & );" << endl;
     293        cout << "forall(ftype FT) void  ?{}( FT *          & );" << endl;
     294        cout << "forall(ftype FT) void  ^?{}( FT *         & );" << endl;
    273295        cout << endl;
    274296
     
    277299        cout << "///////////////////////" << endl;
    278300
    279         cout << "forall( ftype FT ) FT *                        ?=?( FT *&, FT * );" << endl;
    280         cout << "forall( ftype FT ) FT *                        ?=?( FT * volatile &, FT * );" << endl;
    281         cout << "forall( ftype FT ) int !?( FT * );" << endl;
    282         cout << "forall( ftype FT ) signed int ?==?( FT *, FT * );" << endl;
    283         cout << "forall( ftype FT ) signed int ?!=?( FT *, FT * );" << endl;
    284         cout << "forall( ftype FT ) FT &                 *?( FT * );" << endl;
    285 
     301        cout << "forall(ftype FT) FT *                  ?=?( FT *&, FT * );" << endl;
     302        cout << "forall(ftype FT) FT *                  ?=?( FT * volatile &, FT * );" << endl;
     303        cout << "forall(ftype FT) int !?( FT * );" << endl;
     304        cout << "forall(ftype FT) signed int ?==?( FT *, FT * );" << endl;
     305        cout << "forall(ftype FT) signed int ?!=?( FT *, FT * );" << endl;
     306        cout << "forall(ftype FT) FT &           *?( FT * );" << endl;
    286307
    287308        for (auto op : pointerOperators) {
     
    387408}
    388409
     410// Local Variables: //
     411// tab-width: 4 //
     412// End: //
  • libcfa/prelude/sync-builtins.cf

    r6a9d4b4 r933f32f  
    323323_Bool __sync_bool_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
    324324#endif
     325forall(dtype T) _Bool __sync_bool_compare_and_swap(T * volatile *, T *, T*, ...);
    325326
    326327char __sync_val_compare_and_swap(volatile char *, char, char,...);
     
    348349unsigned __int128 __sync_val_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...);
    349350#endif
     351forall(dtype T) T * __sync_val_compare_and_swap(T * volatile *, T *, T*,...);
    350352
    351353char __sync_lock_test_and_set(volatile char *, char,...);
     
    434436#endif
    435437
    436 char __atomic_exchange_n(volatile char *, volatile char *, int);
     438char __atomic_exchange_n(volatile char *, char, int);
    437439char __atomic_exchange_1(volatile char *, char, int);
    438440void __atomic_exchange(volatile char *, volatile char *, volatile char *, int);
    439 signed char __atomic_exchange_n(volatile signed char *, volatile signed char *, int);
     441signed char __atomic_exchange_n(volatile signed char *, signed char, int);
    440442signed char __atomic_exchange_1(volatile signed char *, signed char, int);
    441443void __atomic_exchange(volatile signed char *, volatile signed char *, volatile signed char *, int);
    442 unsigned char __atomic_exchange_n(volatile unsigned char *, volatile unsigned char *, int);
     444unsigned char __atomic_exchange_n(volatile unsigned char *, unsigned char, int);
    443445unsigned char __atomic_exchange_1(volatile unsigned char *, unsigned char, int);
    444446void __atomic_exchange(volatile unsigned char *, volatile unsigned char *, volatile unsigned char *, int);
    445 signed short __atomic_exchange_n(volatile signed short *, volatile signed short *, int);
     447signed short __atomic_exchange_n(volatile signed short *, signed short, int);
    446448signed short __atomic_exchange_2(volatile signed short *, signed short, int);
    447449void __atomic_exchange(volatile signed short *, volatile signed short *, volatile signed short *, int);
    448 unsigned short __atomic_exchange_n(volatile unsigned short *, volatile unsigned short *, int);
     450unsigned short __atomic_exchange_n(volatile unsigned short *, unsigned short, int);
    449451unsigned short __atomic_exchange_2(volatile unsigned short *, unsigned short, int);
    450452void __atomic_exchange(volatile unsigned short *, volatile unsigned short *, volatile unsigned short *, int);
    451 signed int __atomic_exchange_n(volatile signed int *, volatile signed int *, int);
     453signed int __atomic_exchange_n(volatile signed int *, signed int, int);
    452454signed int __atomic_exchange_4(volatile signed int *, signed int, int);
    453455void __atomic_exchange(volatile signed int *, volatile signed int *, volatile signed int *, int);
    454 unsigned int __atomic_exchange_n(volatile unsigned int *, volatile unsigned int *, int);
     456unsigned int __atomic_exchange_n(volatile unsigned int *, unsigned int, int);
    455457unsigned int __atomic_exchange_4(volatile unsigned int *, unsigned int, int);
    456458void __atomic_exchange(volatile unsigned int *, volatile unsigned int *, volatile unsigned int *, int);
    457 signed long long int __atomic_exchange_n(volatile signed long long int *, volatile signed long long int *, int);
     459signed long long int __atomic_exchange_n(volatile signed long long int *, signed long long int, int);
    458460signed long long int __atomic_exchange_8(volatile signed long long int *, signed long long int, int);
    459461void __atomic_exchange(volatile signed long long int *, volatile signed long long int *, volatile signed long long int *, int);
    460 unsigned long long int __atomic_exchange_n(volatile unsigned long long int *, volatile unsigned long long int *, int);
     462unsigned long long int __atomic_exchange_n(volatile unsigned long long int *, unsigned long long int, int);
    461463unsigned long long int __atomic_exchange_8(volatile unsigned long long int *, unsigned long long int, int);
    462464void __atomic_exchange(volatile unsigned long long int *, volatile unsigned long long int *, volatile unsigned long long int *, int);
    463465#if defined(__SIZEOF_INT128__)
    464 signed __int128 __atomic_exchange_n(volatile signed __int128 *, volatile signed __int128 *, int);
     466signed __int128 __atomic_exchange_n(volatile signed __int128 *, signed __int128, int);
    465467signed __int128 __atomic_exchange_16(volatile signed __int128 *, signed __int128, int);
    466468void __atomic_exchange(volatile signed __int128 *, volatile signed __int128 *, volatile signed __int128 *, int);
    467 unsigned __int128 __atomic_exchange_n(volatile unsigned __int128 *, volatile unsigned __int128 *, int);
     469unsigned __int128 __atomic_exchange_n(volatile unsigned __int128 *, unsigned __int128, int);
    468470unsigned __int128 __atomic_exchange_16(volatile unsigned __int128 *, unsigned __int128, int);
    469471void __atomic_exchange(volatile unsigned __int128 *, volatile unsigned __int128 *, volatile unsigned __int128 *, int);
    470472#endif
     473forall(dtype T) T * __atomic_exchange_n(T * volatile *, T *, int);
     474forall(dtype T) void __atomic_exchange(T * volatile *, T * volatile *, T * volatile *, int);
    471475
    472476_Bool __atomic_load_n(const volatile _Bool *, int);
     
    507511void __atomic_load(const volatile unsigned __int128 *, volatile unsigned __int128 *, int);
    508512#endif
     513forall(dtype T) T * __atomic_load_n(T * const volatile *, int);
     514forall(dtype T) void __atomic_load(T * const volatile *, T **, int);
    509515
    510516_Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int);
     
    543549_Bool __atomic_compare_exchange   (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, _Bool, int, int);
    544550#endif
     551forall(dtype T) _Bool __atomic_compare_exchange_n (T * volatile *, T **, T*, _Bool, int, int);
     552forall(dtype T) _Bool __atomic_compare_exchange   (T * volatile *, T **, T**, _Bool, int, int);
    545553
    546554void __atomic_store_n(volatile _Bool *, _Bool, int);
     
    581589void __atomic_store(volatile unsigned __int128 *, unsigned __int128 *, int);
    582590#endif
     591forall(dtype T) void __atomic_store_n(T * volatile *, T *, int);
     592forall(dtype T) void __atomic_store(T * volatile *, T **, int);
    583593
    584594char __atomic_add_fetch  (volatile char *, char, int);
Note: See TracChangeset for help on using the changeset viewer.