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 Feb 8 12:47:59 2018 |
---|
13 | // Update Count : 19 |
---|
14 | // |
---|
15 | |
---|
16 | // exception implementation |
---|
17 | |
---|
18 | typedef unsigned long long __cfaabi_abi_exception_type_t; |
---|
19 | |
---|
20 | #include "../src/virtual.h" |
---|
21 | #include "../src/exception.h" |
---|
22 | |
---|
23 | void exit( int status, const char fmt[], ... ) __attribute__ (( format(printf, 2, 3), __nothrow__, __leaf__, __noreturn__ )); |
---|
24 | void abort ( const char fmt[], ... ) __attribute__ (( format(printf, 1, 2), __nothrow__, __leaf__, __noreturn__ )); |
---|
25 | |
---|
26 | // increment/decrement unification |
---|
27 | |
---|
28 | static inline forall( dtype T | { T& ?+=?( T&, one_t ); } ) |
---|
29 | T& ++? ( T& x ) { return x += 1; } |
---|
30 | |
---|
31 | static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?+=?( T&, one_t ); } ) |
---|
32 | T& ?++ ( T& x ) { T tmp = x; x += 1; return tmp; } |
---|
33 | |
---|
34 | static inline forall( dtype T | { T& ?-=?( T&, one_t ); } ) |
---|
35 | T& --? ( T& x ) { return x -= 1; } |
---|
36 | |
---|
37 | static inline forall( dtype T | sized(T) | { void ?{}( T&, T ); void ^?{}( T& ); T& ?-=?( T&, one_t ); } ) |
---|
38 | T& ?-- ( T& x ) { T tmp = x; x -= 1; return tmp; } |
---|
39 | |
---|
40 | // exponentiation operator implementation |
---|
41 | |
---|
42 | extern "C" { |
---|
43 | float powf( float x, float y ); |
---|
44 | double pow( double x, double y ); |
---|
45 | long double powl( long double x, long double y ); |
---|
46 | float _Complex cpowf( float _Complex x, _Complex float z ); |
---|
47 | double _Complex cpow( double _Complex x, _Complex double z ); |
---|
48 | long double _Complex cpowl( long double _Complex x, _Complex long double z ); |
---|
49 | } // extern "C" |
---|
50 | |
---|
51 | static inline float ?\?( float x, float y ) { return powf( x, y ); } |
---|
52 | static inline double ?\?( double x, double y ) { return pow( x, y ); } |
---|
53 | static inline long double ?\?( long double x, long double y ) { return powl( x, y ); } |
---|
54 | static inline float _Complex ?\?( float _Complex x, _Complex float y ) { return cpowf(x, y ); } |
---|
55 | static inline double _Complex ?\?( double _Complex x, _Complex double y ) { return cpow( x, y ); } |
---|
56 | static inline long double _Complex ?\?( long double _Complex x, _Complex long double y ) { return cpowl( x, y ); } |
---|
57 | |
---|
58 | static inline long int ?\?( long int ep, unsigned long int y ) { // disallow negative exponent |
---|
59 | if ( y == 0 ) return 1; // base case |
---|
60 | if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only |
---|
61 | typeof( ep ) op = 1; // accumulate odd product |
---|
62 | for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) |
---|
63 | if ( (y & 1) == 1 ) op *= ep; // odd ? |
---|
64 | ep *= ep; |
---|
65 | } // for |
---|
66 | return ep * op; |
---|
67 | } // ?\? |
---|
68 | |
---|
69 | static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); } ) |
---|
70 | T ?\?( T ep, unsigned long int y ) { |
---|
71 | if ( y == 0 ) return 1; |
---|
72 | T op = 1; |
---|
73 | for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) |
---|
74 | if ( (y & 1) == 1 ) op = op * ep; // odd ? |
---|
75 | ep = ep * ep; |
---|
76 | } // for |
---|
77 | return ep * op; |
---|
78 | } // ?\? |
---|
79 | |
---|
80 | // unsigned computation may be faster and larger |
---|
81 | static inline unsigned long int ?\?( unsigned long int ep, unsigned long int y ) { // disallow negative exponent |
---|
82 | if ( y == 0 ) return 1; // base case |
---|
83 | if ( ep == 2 ) return ep << (y - 1); // special case, positive shifting only |
---|
84 | typeof( ep ) op = 1; // accumulate odd product |
---|
85 | for ( ; y > 1; y >>= 1 ) { // squaring exponentiation, O(log2 y) |
---|
86 | if ( (y & 1) == 1 ) op *= ep; // odd ? |
---|
87 | ep *= ep; |
---|
88 | } // for |
---|
89 | return ep * op; |
---|
90 | } // ?\? |
---|
91 | |
---|
92 | static inline double ?\?( long int x, signed long int y ) { // allow negative exponent |
---|
93 | if ( y >= 0 ) return (double)(x \ (unsigned long int)y); |
---|
94 | else return 1.0 / x \ (unsigned int)(-y); |
---|
95 | } // ?\? |
---|
96 | |
---|
97 | // FIXME (x \ (unsigned long int)y) relies on X ?\?(T, unsigned long) a function that is neither |
---|
98 | // defined, nor passed as an assertion parameter. Without user-defined conversions, cannot specify |
---|
99 | // X as a type that casts to double, yet it doesn't make sense to write functions with that type |
---|
100 | // signature where X is double. |
---|
101 | |
---|
102 | // static inline forall( otype T | { void ?{}( T & this, one_t ); T ?*?( T, T ); double ?/?( double, T ); } ) |
---|
103 | // double ?\?( T x, signed long int y ) { |
---|
104 | // if ( y >= 0 ) return (double)(x \ (unsigned long int)y); |
---|
105 | // else return 1.0 / x \ (unsigned long int)(-y); |
---|
106 | // } // ?\? |
---|
107 | |
---|
108 | static inline long int ?\=?( long int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
109 | static inline unsigned long int ?\=?( unsigned long int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
110 | static inline int ?\=?( int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
111 | static inline unsigned int ?\=?( unsigned int & x, unsigned long int y ) { x = x \ y; return x; } |
---|
112 | |
---|
113 | // Local Variables: // |
---|
114 | // mode: c // |
---|
115 | // tab-width: 4 // |
---|
116 | // End: // |
---|