Changeset 933f32f for libcfa/prelude
- Timestamp:
- May 24, 2019, 10:19:41 AM (6 years ago)
- Branches:
- ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum
- 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. - Location:
- libcfa/prelude
- Files:
-
- 5 edited
-
builtins.c (modified) (4 diffs)
-
extras.c (modified) (1 diff)
-
extras.regx (modified) (1 diff)
-
prelude-gen.cc (modified) (11 diffs)
-
sync-builtins.cf (modified) (6 diffs)
Legend:
- Unmodified
- Added
- Removed
-
libcfa/prelude/builtins.c
r6a9d4b4 r933f32f 10 10 // Created On : Fri Jul 21 16:21:03 2017 11 11 // Last Modified By : Peter A. Buhr 12 // Last Modified On : Sun Aug 5 21:40:38 201813 // Update Count : 2012 // Last Modified On : Tue Mar 26 23:10:36 2019 13 // Update Count : 95 14 14 // 15 15 … … 42 42 typedef unsigned long long __cfaabi_abi_exception_type_t; 43 43 44 #include <limits.h> // CHAR_BIT 44 45 #include "../src/virtual.h" 45 46 #include "../src/exception.h" … … 50 51 // increment/decrement unification 51 52 52 static inline forall( dtype T | { T& ?+=?( T&, one_t ); } ) 53 T& ++? ( T& x ) { return x += 1; } 53 static inline { 54 forall( dtype DT | { DT & ?+=?( DT &, one_t ); } ) 55 DT & ++?( DT & x ) { return x += 1; } 54 56 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; } 57 59 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; } 60 62 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. 69 static inline forall( dtype DT | sized(DT) ) DT * intptr( uintptr_t addr ) { return (DT *)addr; } 63 70 64 71 // exponentiation operator implementation … … 73 80 } // extern "C" 74 81 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 ); } 82 static 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 81 90 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 92 94 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 103 106 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 } // ?\? 107 static 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 115 114 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__() 120 121 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. 122 static 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 125 126 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__ 131 130 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; } 131 static 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 136 137 137 138 // 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 2 2 #include <stdint.h> // intX_t, uintX_t, where X is 8, 16, 32, 64 3 3 #include <uchar.h> // char16_t, char32_t -
libcfa/prelude/extras.regx
r6a9d4b4 r933f32f 1 1 typedef.* size_t; 2 2 typedef.* ptrdiff_t; 3 typedef.* intptr_t; 4 typedef.* uintptr_t; 3 5 typedef.* __int8_t; 4 6 typedef.* __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 1 16 #include <algorithm> 2 17 #include <array> … … 11 26 bool hasComparison; 12 27 } 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 , }, 16 31 { "signed short" , false, true , }, 17 32 { "unsigned short" , false, true , }, … … 34 49 #if defined(__i386__) || defined(__ia64__) || defined(__x86_64__) 35 50 { "__float80" , true , true , }, 36 { "_ Float128", true , true , },51 { "__float128" , true , true , }, 37 52 #endif 38 53 }; … … 103 118 { "?!=?", false, "signed int", Normal, "" }, 104 119 { "?=?", true, "", Normal, "" }, // void * LHS, zero_t RHS ??? 105 { "*?", false, "&", Normal, " | sized(DT)" }, // & ??? 120 // { "*?", false, "&", Normal, " | sized(DT)" }, // & ??? 121 { "*?", false, "&", Normal, "" }, // & ??? 106 122 107 123 { "?-?", false, "ptrdiff_t", Normal, " | sized(DT)" }, … … 150 166 cout << endl; 151 167 152 cout << "signed int ?==?( zero_t, zero_t ), 153 cout << "signed int ?==?( one_t, one_t ), 154 cout << "signed int ?==?( _Bool, _Bool ), 155 cout << "signed int 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; 156 172 157 173 for (auto op : arithmeticOperators) { … … 188 204 cout << "// Arithmetic Constructors //" << endl; 189 205 cout << "/////////////////////////////" << endl; 206 cout << endl; 207 190 208 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 << ")"; 196 214 } 197 215 cout << ";" << endl; 198 cout << "void \t^?{}( " << type << " & );" << endl;216 cout << "void ^?{}( " << type << " & );" << endl; 199 217 }; 200 218 201 219 otype("zero_t"); 220 cout << endl; 202 221 otype("one_t"); 222 cout << endl; 203 223 otype("_Bool", true); 204 otype("char", true); 205 otype("signed char", true); 206 otype("unsigned char", true); 224 cout << endl; 207 225 208 226 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; 211 231 cout << "void ^?{}(" << type.name << " &);" << endl; 212 232 cout << endl; … … 217 237 cout << "// Pointer Constructors //" << endl; 218 238 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; 221 243 222 244 // generate qualifiers … … 242 264 for (auto cvq : qualifiersPair) { 243 265 for (auto is_vol : { " ", "volatile" }) { 244 cout << "forall(dtype DT) void 266 cout << "forall(dtype DT) void ?{}(" << cvq.first << type << " * " << is_vol << " &, " << cvq.second << "DT *);" << endl; 245 267 } 246 268 } 247 269 for (auto cvq : qualifiersSingle) { 248 270 for (auto is_vol : { " ", "volatile" }) { 249 cout << "forall(dtype DT) void 271 cout << "forall(dtype DT) void ?{}(" << cvq << type << " * " << is_vol << " &);" << endl; 250 272 } 251 273 for (auto is_vol : { " ", "volatile" }) { … … 269 291 cout << "forall(ftype FT) FT * ?=?( FT * &, zero_t );" << endl; 270 292 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; 273 295 cout << endl; 274 296 … … 277 299 cout << "///////////////////////" << endl; 278 300 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; 286 307 287 308 for (auto op : pointerOperators) { … … 387 408 } 388 409 410 // Local Variables: // 411 // tab-width: 4 // 412 // End: // -
libcfa/prelude/sync-builtins.cf
r6a9d4b4 r933f32f 323 323 _Bool __sync_bool_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...); 324 324 #endif 325 forall(dtype T) _Bool __sync_bool_compare_and_swap(T * volatile *, T *, T*, ...); 325 326 326 327 char __sync_val_compare_and_swap(volatile char *, char, char,...); … … 348 349 unsigned __int128 __sync_val_compare_and_swap_16(volatile unsigned __int128 *, unsigned __int128, unsigned __int128,...); 349 350 #endif 351 forall(dtype T) T * __sync_val_compare_and_swap(T * volatile *, T *, T*,...); 350 352 351 353 char __sync_lock_test_and_set(volatile char *, char,...); … … 434 436 #endif 435 437 436 char __atomic_exchange_n(volatile char *, volatile char *, int);438 char __atomic_exchange_n(volatile char *, char, int); 437 439 char __atomic_exchange_1(volatile char *, char, int); 438 440 void __atomic_exchange(volatile char *, volatile char *, volatile char *, int); 439 signed char __atomic_exchange_n(volatile signed char *, volatile signed char *, int);441 signed char __atomic_exchange_n(volatile signed char *, signed char, int); 440 442 signed char __atomic_exchange_1(volatile signed char *, signed char, int); 441 443 void __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);444 unsigned char __atomic_exchange_n(volatile unsigned char *, unsigned char, int); 443 445 unsigned char __atomic_exchange_1(volatile unsigned char *, unsigned char, int); 444 446 void __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);447 signed short __atomic_exchange_n(volatile signed short *, signed short, int); 446 448 signed short __atomic_exchange_2(volatile signed short *, signed short, int); 447 449 void __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);450 unsigned short __atomic_exchange_n(volatile unsigned short *, unsigned short, int); 449 451 unsigned short __atomic_exchange_2(volatile unsigned short *, unsigned short, int); 450 452 void __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);453 signed int __atomic_exchange_n(volatile signed int *, signed int, int); 452 454 signed int __atomic_exchange_4(volatile signed int *, signed int, int); 453 455 void __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);456 unsigned int __atomic_exchange_n(volatile unsigned int *, unsigned int, int); 455 457 unsigned int __atomic_exchange_4(volatile unsigned int *, unsigned int, int); 456 458 void __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);459 signed long long int __atomic_exchange_n(volatile signed long long int *, signed long long int, int); 458 460 signed long long int __atomic_exchange_8(volatile signed long long int *, signed long long int, int); 459 461 void __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);462 unsigned long long int __atomic_exchange_n(volatile unsigned long long int *, unsigned long long int, int); 461 463 unsigned long long int __atomic_exchange_8(volatile unsigned long long int *, unsigned long long int, int); 462 464 void __atomic_exchange(volatile unsigned long long int *, volatile unsigned long long int *, volatile unsigned long long int *, int); 463 465 #if defined(__SIZEOF_INT128__) 464 signed __int128 __atomic_exchange_n(volatile signed __int128 *, volatile signed __int128 *, int);466 signed __int128 __atomic_exchange_n(volatile signed __int128 *, signed __int128, int); 465 467 signed __int128 __atomic_exchange_16(volatile signed __int128 *, signed __int128, int); 466 468 void __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);469 unsigned __int128 __atomic_exchange_n(volatile unsigned __int128 *, unsigned __int128, int); 468 470 unsigned __int128 __atomic_exchange_16(volatile unsigned __int128 *, unsigned __int128, int); 469 471 void __atomic_exchange(volatile unsigned __int128 *, volatile unsigned __int128 *, volatile unsigned __int128 *, int); 470 472 #endif 473 forall(dtype T) T * __atomic_exchange_n(T * volatile *, T *, int); 474 forall(dtype T) void __atomic_exchange(T * volatile *, T * volatile *, T * volatile *, int); 471 475 472 476 _Bool __atomic_load_n(const volatile _Bool *, int); … … 507 511 void __atomic_load(const volatile unsigned __int128 *, volatile unsigned __int128 *, int); 508 512 #endif 513 forall(dtype T) T * __atomic_load_n(T * const volatile *, int); 514 forall(dtype T) void __atomic_load(T * const volatile *, T **, int); 509 515 510 516 _Bool __atomic_compare_exchange_n(volatile char *, char *, char, _Bool, int, int); … … 543 549 _Bool __atomic_compare_exchange (volatile unsigned __int128 *, unsigned __int128 *, unsigned __int128 *, _Bool, int, int); 544 550 #endif 551 forall(dtype T) _Bool __atomic_compare_exchange_n (T * volatile *, T **, T*, _Bool, int, int); 552 forall(dtype T) _Bool __atomic_compare_exchange (T * volatile *, T **, T**, _Bool, int, int); 545 553 546 554 void __atomic_store_n(volatile _Bool *, _Bool, int); … … 581 589 void __atomic_store(volatile unsigned __int128 *, unsigned __int128 *, int); 582 590 #endif 591 forall(dtype T) void __atomic_store_n(T * volatile *, T *, int); 592 forall(dtype T) void __atomic_store(T * volatile *, T **, int); 583 593 584 594 char __atomic_add_fetch (volatile char *, char, int);
Note: See TracChangeset
for help on using the changeset viewer.
