Debian Codegraph @

gcc/testsuite/gcc.target/aarch64/saturating-arithmetic-signed.c

raw
1 /* { dg-do run } */
2 /* { dg-options "-O2 --save-temps -mearly-ra=none -fno-schedule-insns2" } */
3 /* { dg-final { check-function-bodies "**" "" "" } } */
4
5 #include <limits.h>
6 #include <stdbool.h>
7 #include <stdint.h>
8
9 /*
10 ** sadd32:
11 ** asr w([0-9]+), w1, 31
12 ** eor w\1, w\1, -2147483648
13 ** adds w([0-9]+), (?:w0, w1|w1, w0)
14 ** csinv w0, w\2, w\1, vc
15 ** ret
16 */
17 int32_t __attribute__((noipa))
18 sadd32 (int32_t __a, int32_t __b)
19 {
20 int32_t sum;
21 bool overflow = __builtin_add_overflow (__a, __b, &sum);
22 return !overflow ? sum : __a < 0 ? INT_MIN : INT_MAX;
23 }
24
25 /*
26 ** sadd32_imm:
27 ** adds w([0-9]+), w0, #67
28 ** mov w([0-9]+), 2147483647
29 ** csel w0, w\1, w\2, vc
30 ** ret
31 */
32 int32_t __attribute__((noipa))
33 sadd32_imm (int32_t __a)
34 {
35 int32_t sum;
36 bool overflow = __builtin_add_overflow (__a, 67, &sum);
37 return !overflow ? sum : __a < 0 ? INT_MIN : INT_MAX;
38 }
39
40 /*
41 ** sadd32_imm2:
42 ** subs w([0-9]+), w0, 67
43 ** mov w([0-9]+), -2147483648
44 ** csel w0, w\1, w\2, vc
45 ** ret
46 */
47 int32_t __attribute__((noipa))
48 sadd32_imm2 (int32_t __a)
49 {
50 int32_t sum;
51 bool overflow = __builtin_add_overflow (__a, -67, &sum);
52 return !overflow ? sum : __a < 0 ? INT_MIN : INT_MAX;
53 }
54
55 /*
56 ** ssub32:
57 ** asr w([0-9]+), w1, 31
58 ** eor w\1, w\1, -2147483648
59 ** subs w([0-9]+), w0, w1
60 ** csel w0, w\2, w\1, vc
61 ** ret
62 */
63 int32_t __attribute__((noipa))
64 ssub32 (int32_t __a, int32_t __b)
65 {
66 int32_t result;
67 bool overflow = __builtin_sub_overflow (__a, __b, &result);
68 return !overflow ? result : __a < 0 ? INT_MIN : INT_MAX;
69 }
70
71 /*
72 ** ssub32_imm:
73 ** subs w([0-9]+), w0, 67
74 ** mov w([0-9]+), -2147483648
75 ** csel w0, w\1, w\2, vc
76 ** ret
77 */
78 int32_t __attribute__((noipa))
79 ssub32_imm (int32_t __a)
80 {
81 int32_t result;
82 bool overflow = __builtin_sub_overflow (__a, 67, &result);
83 return !overflow ? result : __a < 0 ? INT_MIN : INT_MAX;
84 }
85
86 /*
87 ** ssub32_imm2:
88 ** adds w([0-9]+), w0, #67
89 ** mov w([0-9]+), 2147483647
90 ** csel w0, w\1, w\2, vc
91 ** ret
92 */
93 int32_t __attribute__((noipa))
94 ssub32_imm2 (int32_t __a)
95 {
96 int32_t result;
97 bool overflow = __builtin_sub_overflow (__a, -67, &result);
98 return !overflow ? result : __a < 0 ? INT_MIN : INT_MAX;
99 }
100
101 /*
102 ** sadd64:
103 ** asr x([0-9]+), x1, 63
104 ** eor x\1, x\1, -9223372036854775808
105 ** adds x([0-9]+), (?:x0, x1|x1, x0)
106 ** csinv x0, x\2, x\1, vc
107 ** ret
108 */
109 int64_t __attribute__((noipa))
110 sadd64 (int64_t __a, int64_t __b)
111 {
112 int64_t sum;
113 bool overflow = __builtin_add_overflow (__a, __b, &sum);
114 return !overflow ? sum : __a < 0 ? LONG_MIN : LONG_MAX;
115 }
116
117 /*
118 ** sadd64_imm:
119 ** adds x([0-9]+), x0, #67
120 ** mov x([0-9]+), 9223372036854775807
121 ** csel x0, x\1, x\2, vc
122 ** ret
123 */
124 int64_t __attribute__((noipa))
125 sadd64_imm (int64_t __a)
126 {
127 int64_t sum;
128 bool overflow = __builtin_add_overflow (__a, (int64_t)67, &sum);
129 return !overflow ? sum : __a < 0 ? LONG_MIN : LONG_MAX;
130 }
131
132 /*
133 ** sadd64_imm2:
134 ** subs x([0-9]+), x0, 67
135 ** mov x([0-9]+), -9223372036854775808
136 ** csel x0, x\1, x\2, vc
137 ** ret
138 */
139 int64_t __attribute__((noipa))
140 sadd64_imm2 (int64_t __a)
141 {
142 int64_t sum;
143 bool overflow = __builtin_add_overflow (__a, (int64_t)-67, &sum);
144 return !overflow ? sum : __a < 0 ? LONG_MIN : LONG_MAX;
145 }
146
147 /*
148 ** ssub64:
149 ** asr x([0-9]+), x1, 63
150 ** eor x\1, x\1, -9223372036854775808
151 ** subs x([0-9]+), x0, x1
152 ** csel x0, x\2, x\1, vc
153 ** ret
154 */
155 int64_t __attribute__((noipa))
156 ssub64 (int64_t __a, int64_t __b)
157 {
158 int64_t result;
159 bool overflow = __builtin_sub_overflow (__a, __b, &result);
160 return !overflow ? result : __a < 0 ? LONG_MIN : LONG_MAX;
161 }
162
163 /*
164 ** ssub64_imm:
165 ** subs x([0-9]+), x0, 67
166 ** mov x([0-9]+), -9223372036854775808
167 ** csel x0, x\1, x\2, vc
168 ** ret
169 */
170 int64_t __attribute__((noipa))
171 ssub64_imm (int64_t __a)
172 {
173 int64_t result;
174 bool overflow = __builtin_sub_overflow (__a, (int64_t) 67, &result);
175 return !overflow ? result : __a < 0 ? LONG_MIN : LONG_MAX;
176 }
177
178 /*
179 ** ssub64_imm2:
180 ** adds x([0-9]+), x0, #67
181 ** mov x([0-9]+), 9223372036854775807
182 ** csel x0, x\1, x\2, vc
183 ** ret
184 */
185 int64_t __attribute__((noipa))
186 ssub64_imm2 (int64_t __a)
187 {
188 int64_t result;
189 bool overflow = __builtin_sub_overflow (__a, (int64_t) -67, &result);
190 return !overflow ? result : __a < 0 ? LONG_MIN : LONG_MAX;
191 }
192
193 int
194 main (void)
195 {
196 /* Addition:
197 SAT_ADD(x, +ve), non-saturating
198 SAT_ADD(x, +ve), saturating
199 SAT_ADD(x, immediate +ve)
200 SAT_ADD(x, immediate -ve)
201 SAT_ADD(x, -ve), non-saturating
202 SAT_ADD(x, -ve), saturating
203
204 Subtraction:
205 SAT_SUB(x, +ve), non-saturating
206 SAT_SUB(x, +ve), saturating
207 SAT_SUB(x, immediate +ve)
208 SAT_SUB(x, immediate -ve)
209 SAT_SUB(x, -ve), non-saturating */
210
211 int32_t a = 4;
212 int32_t b = 70;
213 int32_t c = 2147483647;
214 int32_t d = (int32_t) -2147483648;
215
216 if (sadd32 (a, b) != (a + b))
217 __builtin_abort ();
218 if (sadd32 (a, c) != c)
219 __builtin_abort ();
220 if (sadd32_imm (a) != (a + 67))
221 __builtin_abort ();
222 if (sadd32_imm2 (a) != (a - 67))
223 __builtin_abort ();
224 if (sadd32 (a, -b) != (a - b))
225 __builtin_abort ();
226 if (sadd32 (a, d) != (d + 4))
227 __builtin_abort ();
228
229 if (ssub32 (a, b) != (a - b))
230 __builtin_abort ();
231 if (ssub32 (-a, c) != d)
232 __builtin_abort ();
233 if (ssub32_imm (a) != (a - 67))
234 __builtin_abort ();
235 if (ssub32_imm2 (a) != (a + 67))
236 __builtin_abort ();
237 if (ssub32 (a, -b) != (a + b))
238 __builtin_abort ();
239
240 int64_t a_64 = a;
241 int64_t b_64 = b;
242 int64_t c_64 = (int64_t) 9223372036854775807;
243 int64_t d_64 = (int64_t) 0x8000000000000000;
244
245 if (sadd64 (a_64, b_64) != (a_64 + b_64))
246 __builtin_abort ();
247 if (sadd64 (a_64, c_64) != c_64)
248 __builtin_abort ();
249 if (sadd64_imm (a_64) != (a_64 + 67))
250 __builtin_abort ();
251 if (sadd64_imm2 (a_64) != (a_64 - 67))
252 __builtin_abort ();
253 if (sadd64 (a_64, -b_64) != (a_64 - b_64))
254 __builtin_abort ();
255 if (sadd64 (a_64, d_64) != (d_64 + 4))
256 __builtin_abort ();
257
258 if (ssub64 (a_64, b_64) != (a_64 - b_64))
259 __builtin_abort ();
260 if (ssub64 (-a_64, c_64) != d_64)
261 __builtin_abort ();
262 if (ssub64_imm (a_64) != (a_64 - 67))
263 __builtin_abort ();
264 if (ssub64_imm2 (a_64) != (a_64 + 67))
265 __builtin_abort ();
266 if (ssub64 (a_64, -b_64) != (a_64 + b_64))
267 __builtin_abort ();
268
269 return 0;
270 }