1 | // |
---|
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. |
---|
6 | // |
---|
7 | // builtins.c -- |
---|
8 | // |
---|
9 | // Author : Peter A. Buhr |
---|
10 | // Created On : Fri Jul 21 16:21:03 2017 |
---|
11 | // Last Modified By : Peter A. Buhr |
---|
12 | // Last Modified On : Thu Nov 21 16:31:39 2019 |
---|
13 | // Update Count : 101 |
---|
14 | // |
---|
15 | |
---|
16 | // type that wraps a pointer and a destructor-like function - used in generating implicit destructor calls for struct members in user-defined functions |
---|
17 | // Note: needs to occur early, because it is used to generate destructor calls during code generation |
---|
18 | forall(dtype T) |
---|
19 | struct __Destructor { |
---|
20 | T * object; |
---|
21 | void (*dtor)(T *); |
---|
22 | }; |
---|
23 | |
---|
24 | // defined destructor in the case that non-generated code wants to use __Destructor |
---|
25 | forall(dtype T) |
---|
26 | static inline void ^?{}(__Destructor(T) & x) { |
---|
27 | if (x.object && x.dtor) { |
---|
28 | x.dtor(x.object); |
---|
29 | } |
---|
30 | } |
---|
31 | |
---|
32 | // easy interface into __Destructor's destructor for easy codegen purposes |
---|
33 | extern "C" { |
---|
34 | forall(dtype T) |
---|
35 | static inline void __destroy_Destructor(__Destructor(T) * dtor) { |
---|
36 | ^(*dtor){}; |
---|
37 | } |
---|
38 | } |
---|
39 | |
---|
40 | // exception implementation |
---|
41 | |
---|
42 | typedef unsigned long long __cfaabi_abi_exception_type_t; |
---|
43 | |
---|
44 | #include <limits.h> // CHAR_BIT |
---|
45 | #include "../src/virtual.h" |
---|
46 | #include "../src/exception.h" |
---|
47 | |
---|
48 | void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )); |
---|
49 | void abort( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); |
---|
50 | |
---|
51 | forall(dtype T) |
---|
52 | static inline T & identity(T & i) { |
---|
53 | return i; |
---|
54 | } |
---|
55 | |
---|
56 | // generator support |
---|
57 | struct $generator { |
---|
58 | inline int; |
---|
59 | }; |
---|
60 | |
---|
61 | static inline void ?{}($generator & this) { ((int&)this) = 0; } |
---|
62 | static inline void ^?{}($generator &) {} |
---|
63 | |
---|
64 | trait is_generator(dtype T) { |
---|
65 | void main(T & this); |
---|
66 | $generator * get_generator(T & this); |
---|
67 | }; |
---|
68 | |
---|
69 | forall(dtype T | is_generator(T)) |
---|
70 | static inline T & resume(T & gen) { |
---|
71 | main(gen); |
---|
72 | return gen; |
---|
73 | } |
---|
74 | |
---|
75 | // implicit increment, decrement if += defined, and implicit not if != defined |
---|
76 | |
---|
77 | static inline { |
---|
78 | forall( dtype DT | { DT & ?+=?( DT &, one_t ); } ) |
---|
79 | DT & ++?( DT & x ) { return x += 1; } |
---|
80 | |
---|
81 | forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?+=?( DT &, one_t ); } ) |
---|
82 | DT & ?++( DT & x ) { DT tmp = x; x += 1; return tmp; } |
---|
83 | |
---|
84 | forall( dtype DT | { DT & ?-=?( DT &, one_t ); } ) |
---|
85 | DT & --?( DT & x ) { return x -= 1; } |
---|
86 | |
---|
87 | forall( dtype DT | sized(DT) | { void ?{}( DT &, DT ); void ^?{}( DT & ); DT & ?-=?( DT &, one_t ); } ) |
---|
88 | DT & ?--( DT & x ) { DT tmp = x; x -= 1; return tmp; } |
---|
89 | |
---|
90 | forall( dtype DT | { int ?!=?( const DT &, zero_t ); } ) |
---|
91 | int !?( const DT & x ) { return !( x != 0 ); } |
---|
92 | } // distribution |
---|
93 | |
---|
94 | // universal typed pointer constant |
---|
95 | static inline forall( dtype DT ) DT * intptr( uintptr_t addr ) { return (DT *)addr; } |
---|
96 | |
---|
97 | // exponentiation operator implementation |
---|
98 | |
---|
99 | extern "C" { |
---|
100 | float powf( float x, float y ); |
---|
101 | double pow( double x, double y ); |
---|
102 | long double powl( long double x, long double y ); |
---|
103 | float _Complex cpowf( float _Complex x, _Complex float z ); |
---|
104 | double _Complex cpow( double _Complex x, _Complex double z ); |
---|
105 | long double _Complex cpowl( long double _Complex x, _Complex long double z ); |
---|
106 | } // extern "C" |
---|
107 | |
---|
108 | static inline { |
---|
109 | float ?\?( float x, float y ) { return powf( x, y ); } |
---|
110 | double ?\?( double x, double y ) { return pow( x, y ); } |
---|
111 | long double ?\?( long double x, long double y ) { return powl( x, y ); } |
---|
112 | float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); } |
---|
113 | double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); } |
---|
114 | long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); } |
---|
115 | } // distribution |
---|
116 | |
---|
117 | #define __CFA_BASE_COMP_1__() if ( ep == 1 ) return 1 |
---|
118 | #define __CFA_BASE_COMP_2__() if ( ep == 2 ) return ep << (y - 1) |
---|
119 | #define __CFA_EXP_OVERFLOW__() if ( y >= sizeof(y) * CHAR_BIT ) return 0 |
---|
120 | |
---|
121 | #define __CFA_EXP__() \ |
---|
122 | if ( y == 0 ) return 1; /* convention */ \ |
---|
123 | __CFA_BASE_COMP_1__(); /* base case */ \ |
---|
124 | __CFA_BASE_COMP_2__(); /* special case, positive shifting for integral types */ \ |
---|
125 | __CFA_EXP_OVERFLOW__(); /* immediate overflow, negative exponent > 2^size-1 */ \ |
---|
126 | typeof(ep) op = 1; /* accumulate odd product */ \ |
---|
127 | for ( ; y > 1; y >>= 1 ) { /* squaring exponentiation, O(log2 y) */ \ |
---|
128 | if ( (y & 1) == 1 ) op = op * ep; /* odd ? */ \ |
---|
129 | ep = ep * ep; \ |
---|
130 | } \ |
---|
131 | return ep * op |
---|
132 | |
---|
133 | static inline { |
---|
134 | long int ?\?( int ep, unsigned int y ) { __CFA_EXP__(); } |
---|
135 | long int ?\?( long int ep, unsigned long int y ) { __CFA_EXP__(); } |
---|
136 | // unsigned computation may be faster and larger |
---|
137 | unsigned long int ?\?( unsigned int ep, unsigned int y ) { __CFA_EXP__(); } |
---|
138 | unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { __CFA_EXP__(); } |
---|
139 | } // distribution |
---|
140 | |
---|
141 | #undef __CFA_BASE_COMP_1__ |
---|
142 | #undef __CFA_BASE_COMP_2__ |
---|
143 | #undef __CFA_EXP_OVERFLOW__ |
---|
144 | #define __CFA_BASE_COMP_1__() |
---|
145 | #define __CFA_BASE_COMP_2__() |
---|
146 | #define __CFA_EXP_OVERFLOW__() |
---|
147 | |
---|
148 | static inline forall( otype OT | { void ?{}( OT & this, one_t ); OT ?*?( OT, OT ); } ) { |
---|
149 | OT ?\?( OT ep, unsigned int y ) { __CFA_EXP__(); } |
---|
150 | OT ?\?( OT ep, unsigned long int y ) { __CFA_EXP__(); } |
---|
151 | } // distribution |
---|
152 | |
---|
153 | #undef __CFA_BASE_COMP_1__ |
---|
154 | #undef __CFA_BASE_COMP_2__ |
---|
155 | #undef __CFA_EXP_OVERFLOW__ |
---|
156 | |
---|
157 | static inline { |
---|
158 | long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
159 | unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
160 | int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
161 | unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
162 | } // distribution |
---|
163 | |
---|
164 | // Local Variables: // |
---|
165 | // mode: c // |
---|
166 | // tab-width: 4 // |
---|
167 | // End: // |
---|