[a5f0529] | 1 | // |
---|
[a1edafa] | 2 | // Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo |
---|
| 3 | // |
---|
| 4 | // The contents of this file are covered under the licence agreement in the |
---|
| 5 | // file "LICENCE" distributed with Cforall. |
---|
[a5f0529] | 6 | // |
---|
| 7 | // builtins.c -- |
---|
| 8 | // |
---|
[a1edafa] | 9 | // Author : Peter A. Buhr |
---|
| 10 | // Created On : Fri Jul 21 16:21:03 2017 |
---|
[88ac8672] | 11 | // Last Modified By : Peter A. Buhr |
---|
[8a97248] | 12 | // Last Modified On : Thu Feb 2 11:33:56 2023 |
---|
| 13 | // Update Count : 135 |
---|
[a5f0529] | 14 | // |
---|
[a1edafa] | 15 | |
---|
[c960331] | 16 | #define __cforall_builtins__ |
---|
| 17 | |
---|
[b867278] | 18 | // type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct members in user-defined functions |
---|
| 19 | // Note: needs to occur early, because it is used to generate destructor calls during code generation |
---|
[fd54fef] | 20 | forall(T &) |
---|
[b867278] | 21 | struct __Destructor { |
---|
| 22 | T * object; |
---|
| 23 | void (*dtor)(T *); |
---|
| 24 | }; |
---|
| 25 | |
---|
| 26 | // defined destructor in the case that non-generated code wants to use __Destructor |
---|
[fd54fef] | 27 | forall(T &) |
---|
[b867278] | 28 | static inline void ^?{}(__Destructor(T) & x) { |
---|
| 29 | if (x.object && x.dtor) { |
---|
| 30 | x.dtor(x.object); |
---|
| 31 | } |
---|
| 32 | } |
---|
| 33 | |
---|
| 34 | // easy interface into __Destructor's destructor for easy codegen purposes |
---|
| 35 | extern "C" { |
---|
[fd54fef] | 36 | forall(T &) |
---|
[b867278] | 37 | static inline void __destroy_Destructor(__Destructor(T) * dtor) { |
---|
| 38 | ^(*dtor){}; |
---|
| 39 | } |
---|
| 40 | } |
---|
| 41 | |
---|
[a1edafa] | 42 | // exception implementation |
---|
| 43 | |
---|
[36982fc] | 44 | typedef unsigned long long __cfaabi_abi_exception_type_t; |
---|
[fa4805f] | 45 | |
---|
[7726839] | 46 | #include <limits.h> // CHAR_BIT |
---|
[bf71cfd] | 47 | #include "../src/virtual.h" |
---|
| 48 | #include "../src/exception.h" |
---|
[a1edafa] | 49 | |
---|
[169d944] | 50 | void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )); |
---|
[f79cdf8] | 51 | void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); |
---|
[169d944] | 52 | |
---|
[fd54fef] | 53 | forall(T &) |
---|
[427854b] | 54 | static inline T & identity(T & i) { |
---|
| 55 | return i; |
---|
| 56 | } |
---|
| 57 | |
---|
| 58 | // generator support |
---|
[e84ab3d] | 59 | struct generator$ { |
---|
[427854b] | 60 | inline int; |
---|
| 61 | }; |
---|
| 62 | |
---|
[e84ab3d] | 63 | static inline void ?{}(generator$ & this) { ((int&)this) = 0; } |
---|
| 64 | static inline void ^?{}(generator$ &) {} |
---|
[427854b] | 65 | |
---|
[8a97248] | 66 | forall( T & ) |
---|
| 67 | trait is_generator { |
---|
[427854b] | 68 | void main(T & this); |
---|
[e84ab3d] | 69 | generator$ * get_generator(T & this); |
---|
[427854b] | 70 | }; |
---|
| 71 | |
---|
[fd54fef] | 72 | forall(T & | is_generator(T)) |
---|
[427854b] | 73 | static inline T & resume(T & gen) { |
---|
| 74 | main(gen); |
---|
| 75 | return gen; |
---|
| 76 | } |
---|
| 77 | |
---|
[0d8266c] | 78 | // implicit increment, decrement if += defined, and implicit not if != defined |
---|
[d2887f7] | 79 | |
---|
[2ead704] | 80 | // C11 reference manual Section 6.5.16 (page101): "An assignment expression has the value of the left operand after the |
---|
| 81 | // assignment, but is not an lvalue." Hence, return a value not a reference. |
---|
[8a30423] | 82 | static inline { |
---|
[8477fc4] | 83 | forall( T | { T ?+=?( T &, one_t ); } ) |
---|
| 84 | T ++?( T & x ) { return x += 1; } |
---|
[d2887f7] | 85 | |
---|
[8477fc4] | 86 | forall( T | { T ?+=?( T &, one_t ); } ) |
---|
| 87 | T ?++( T & x ) { T tmp = x; x += 1; return tmp; } |
---|
[d2887f7] | 88 | |
---|
[8477fc4] | 89 | forall( T | { T ?-=?( T &, one_t ); } ) |
---|
| 90 | T --?( T & x ) { return x -= 1; } |
---|
[d2887f7] | 91 | |
---|
[8477fc4] | 92 | forall( T | { T ?-=?( T &, one_t ); } ) |
---|
| 93 | T ?--( T & x ) { T tmp = x; x -= 1; return tmp; } |
---|
[0d8266c] | 94 | |
---|
[8477fc4] | 95 | forall( T | { int ?!=?( T, zero_t ); } ) |
---|
| 96 | int !?( T & x ) { return !( x != 0 ); } |
---|
[8a30423] | 97 | } // distribution |
---|
[7579ac0] | 98 | |
---|
| 99 | // universal typed pointer constant |
---|
[fd54fef] | 100 | static inline forall( DT & ) DT * intptr( uintptr_t addr ) { return (DT *)addr; } |
---|
[04423b53] | 101 | static inline forall( ftype FT ) FT * intptr( uintptr_t addr ) { return (FT *)addr; } |
---|
[a1edafa] | 102 | |
---|
[cf5af9c] | 103 | #if defined(__SIZEOF_INT128__) |
---|
[b56f55c] | 104 | // constructor for 128-bit numbers (all constants are unsigned as +/- are operators) |
---|
| 105 | static inline void ?{}( unsigned int128 & this, unsigned long int h, unsigned long int l ) { |
---|
| 106 | this = (unsigned int128)h << 64 | (unsigned int128)l; |
---|
| 107 | } // ?{} |
---|
[cf5af9c] | 108 | #endif // __SIZEOF_INT128__ |
---|
[b56f55c] | 109 | |
---|
[c99a0d1] | 110 | // for-control index constraints |
---|
| 111 | // forall( T | { void ?{}( T &, zero_t ); void ?{}( T &, one_t ); T ?+=?( T &, T ); T ?-=?( T &, T ); int ?<?( T, T ); } ) |
---|
| 112 | // static inline T __for_control_index_constraints__( T t ) { return t; } |
---|
| 113 | |
---|
[a1edafa] | 114 | // exponentiation operator implementation |
---|
| 115 | |
---|
| 116 | extern "C" { |
---|
| 117 | float powf( float x, float y ); |
---|
| 118 | double pow( double x, double y ); |
---|
| 119 | long double powl( long double x, long double y ); |
---|
| 120 | float _Complex cpowf( float _Complex x, _Complex float z ); |
---|
| 121 | double _Complex cpow( double _Complex x, _Complex double z ); |
---|
| 122 | long double _Complex cpowl( long double _Complex x, _Complex long double z ); |
---|
| 123 | } // extern "C" |
---|
| 124 | |
---|
[8a30423] | 125 | static inline { |
---|
| 126 | float ?\?( float x, float y ) { return powf( x, y ); } |
---|
| 127 | double ?\?( double x, double y ) { return pow( x, y ); } |
---|
| 128 | long double ?\?( long double x, long double y ) { return powl( x, y ); } |
---|
| 129 | float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); } |
---|
| 130 | double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); } |
---|
| 131 | long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); } |
---|
| 132 | } // distribution |
---|
[a1edafa] | 133 | |
---|
[88ac8672] | 134 | #define __CFA_BASE_COMP_1__() if ( x == 1 ) return 1 |
---|
| 135 | #define __CFA_BASE_COMP_2__() if ( x == 2 ) return x << (y - 1) |
---|
[7726839] | 136 | #define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0 |
---|
| 137 | |
---|
[8dbfb7e] | 138 | #define __CFA_EXP__() \ |
---|
[8a30423] | 139 | if ( y == 0 ) return 1; /* convention */ \ |
---|
[7726839] | 140 | __CFA_BASE_COMP_1__(); /* base case */ \ |
---|
| 141 | __CFA_BASE_COMP_2__(); /* special case, positive shifting for integral types */ \ |
---|
| 142 | __CFA_EXP_OVERFLOW__(); /* immediate overflow, negative exponent > 2^size-1 */ \ |
---|
[88ac8672] | 143 | typeof(x) op = 1; /* accumulate odd product */ \ |
---|
[8dbfb7e] | 144 | for ( ; y > 1; y >>= 1 ) { /* squaring exponentiation, O(log2 y) */ \ |
---|
[88ac8672] | 145 | if ( (y & 1) == 1 ) op = op * x; /* odd ? */ \ |
---|
| 146 | x = x * x; \ |
---|
[8dbfb7e] | 147 | } \ |
---|
[88ac8672] | 148 | return x * op |
---|
[8dbfb7e] | 149 | |
---|
[8a30423] | 150 | static inline { |
---|
[24d6572] | 151 | int ?\?( int x, unsigned int y ) { __CFA_EXP__(); } |
---|
[88ac8672] | 152 | long int ?\?( long int x, unsigned long int y ) { __CFA_EXP__(); } |
---|
| 153 | long long int ?\?( long long int x, unsigned long long int y ) { __CFA_EXP__(); } |
---|
[8a30423] | 154 | // unsigned computation may be faster and larger |
---|
[24d6572] | 155 | unsigned int ?\?( unsigned int x, unsigned int y ) { __CFA_EXP__(); } |
---|
[88ac8672] | 156 | unsigned long int ?\?( unsigned long int x, unsigned long int y ) { __CFA_EXP__(); } |
---|
| 157 | unsigned long long int ?\?( unsigned long long int x, unsigned long long int y ) { __CFA_EXP__(); } |
---|
[8a30423] | 158 | } // distribution |
---|
[a1edafa] | 159 | |
---|
[8dbfb7e] | 160 | #undef __CFA_BASE_COMP_1__ |
---|
| 161 | #undef __CFA_BASE_COMP_2__ |
---|
| 162 | #undef __CFA_EXP_OVERFLOW__ |
---|
| 163 | #define __CFA_BASE_COMP_1__() |
---|
| 164 | #define __CFA_BASE_COMP_2__() |
---|
| 165 | #define __CFA_EXP_OVERFLOW__() |
---|
[e472d54] | 166 | |
---|
[fd54fef] | 167 | static inline forall( OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) { |
---|
[88ac8672] | 168 | OT ?\?( OT x, unsigned int y ) { __CFA_EXP__(); } |
---|
| 169 | OT ?\?( OT x, unsigned long int y ) { __CFA_EXP__(); } |
---|
| 170 | OT ?\?( OT x, unsigned long long int y ) { __CFA_EXP__(); } |
---|
[8a30423] | 171 | } // distribution |
---|
[8dbfb7e] | 172 | |
---|
| 173 | #undef __CFA_BASE_COMP_1__ |
---|
| 174 | #undef __CFA_BASE_COMP_2__ |
---|
| 175 | #undef __CFA_EXP_OVERFLOW__ |
---|
[a1edafa] | 176 | |
---|
[8a30423] | 177 | static inline { |
---|
[24d6572] | 178 | int ?\=?( int & x, unsigned int y ) { x = x \ y; return x; } |
---|
[8a30423] | 179 | long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
[88ac8672] | 180 | long long int ?\=?( long long int & x, unsigned long long int y ) { x = x \ y; return x; } |
---|
[24d6572] | 181 | unsigned int ?\=?( unsigned int & x, unsigned int y ) { x = x \ y; return x; } |
---|
[8a30423] | 182 | unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
[88ac8672] | 183 | unsigned long long int ?\=?( unsigned long long int & x, unsigned long long int y ) { x = x \ y; return x; } |
---|
[8a30423] | 184 | } // distribution |
---|
[a1edafa] | 185 | |
---|
| 186 | // Local Variables: // |
---|
| 187 | // mode: c // |
---|
| 188 | // tab-width: 4 // |
---|
| 189 | // End: // |
---|