1 #include <limits.h>
2 #include <float.h>
3
4 #include "libgccjit.h"
5
6 #include "harness.h"
7
8 static void
9 make_test_of_constant (gcc_jit_context *ctxt,
10 gcc_jit_type *type,
11 gcc_jit_rvalue *rvalue,
12 const char *funcname)
13 {
14 /* Make a test function of the form:
15 T funcname (void)
16 {
17 return VALUE;
18 }
19 and return a debug dump of VALUE so that
20 the caller can sanity-check the debug dump implementation.
21 */
22 gcc_jit_function *test_fn =
23 gcc_jit_context_new_function (ctxt, NULL,
24 GCC_JIT_FUNCTION_EXPORTED,
25 type,
26 funcname,
27 0, NULL,
28 0);
29 gcc_jit_block *initial = gcc_jit_function_new_block (test_fn, "initial");
30 gcc_jit_block_end_with_return (initial, NULL, rvalue);
31 }
32
33 /**********************************************************************
34 Tests of gcc_jit_context_new_rvalue_from_int.
35 **********************************************************************/
36
37 static const char *
38 make_test_of_int_constant (gcc_jit_context *ctxt,
39 gcc_jit_type *type,
40 int value,
41 const char *funcname)
42 {
43 /* Make a test function of the form:
44 int funcname (void)
45 {
46 return VALUE;
47 }
48 and return a debug dump of VALUE so that
49 the caller can sanity-check the debug dump implementation.
50 */
51 gcc_jit_rvalue *rvalue =
52 gcc_jit_context_new_rvalue_from_int (ctxt, type, value);
53 make_test_of_constant (ctxt, type, rvalue, funcname);
54 return gcc_jit_object_get_debug_string (
55 gcc_jit_rvalue_as_object (rvalue));
56 }
57
58 static void
59 make_tests_of_int_constants (gcc_jit_context *ctxt)
60 {
61 gcc_jit_type *int_type =
62 gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_INT);
63
64 CHECK_STRING_VALUE (
65 make_test_of_int_constant (ctxt,
66 int_type,
67 0,
68 "test_int_constant_0"),
69 "(int)0");
70 make_test_of_int_constant (ctxt,
71 int_type,
72 INT_MAX,
73 "test_int_constant_INT_MAX");
74 make_test_of_int_constant (ctxt,
75 int_type,
76 INT_MIN,
77 "test_int_constant_INT_MIN");
78 }
79
80 static void
81 verify_int_constants (gcc_jit_result *result)
82 {
83 typedef int (*test_fn) (void);
84
85 test_fn test_int_constant_0 =
86 (test_fn)gcc_jit_result_get_code (result,
87 "test_int_constant_0");
88 CHECK_NON_NULL (test_int_constant_0);
89 CHECK_VALUE (test_int_constant_0 (), 0);
90
91 test_fn test_int_constant_INT_MAX =
92 (test_fn)gcc_jit_result_get_code (result,
93 "test_int_constant_INT_MAX");
94 CHECK_NON_NULL (test_int_constant_INT_MAX);
95 CHECK_VALUE (test_int_constant_INT_MAX (), INT_MAX);
96
97 test_fn test_int_constant_INT_MIN =
98 (test_fn)gcc_jit_result_get_code (result,
99 "test_int_constant_INT_MIN");
100 CHECK_NON_NULL (test_int_constant_INT_MIN);
101 CHECK_VALUE (test_int_constant_INT_MIN (), INT_MIN);
102 }
103
104 /**********************************************************************
105 Tests of gcc_jit_context_new_rvalue_from_long.
106 **********************************************************************/
107
108 static const char *
109 make_test_of_long_constant (gcc_jit_context *ctxt,
110 gcc_jit_type *type,
111 long value,
112 const char *funcname)
113 {
114 /* Make a test function of the form:
115 long funcname (void)
116 {
117 return VALUE;
118 }
119 and return a debug dump of VALUE so that
120 the caller can sanity-check the debug dump implementation.
121 */
122 gcc_jit_rvalue *rvalue =
123 gcc_jit_context_new_rvalue_from_long (ctxt, type, value);
124 make_test_of_constant (ctxt, type, rvalue, funcname);
125 return gcc_jit_object_get_debug_string (
126 gcc_jit_rvalue_as_object (rvalue));
127 }
128
129 static void
130 make_tests_of_long_constants (gcc_jit_context *ctxt)
131 {
132 gcc_jit_type *long_type =
133 gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_LONG);
134
135 CHECK_STRING_VALUE (
136 make_test_of_long_constant (ctxt,
137 long_type,
138 0,
139 "test_long_constant_0"),
140 "(long)0");
141 make_test_of_long_constant (ctxt,
142 long_type,
143 LONG_MAX,
144 "test_long_constant_LONG_MAX");
145 make_test_of_long_constant (ctxt,
146 long_type,
147 LONG_MIN,
148 "test_long_constant_LONG_MIN");
149 }
150
151 static void
152 verify_long_constants (gcc_jit_result *result)
153 {
154 typedef long (*test_fn) (void);
155
156 test_fn test_long_constant_0 =
157 (test_fn)gcc_jit_result_get_code (result,
158 "test_long_constant_0");
159 CHECK_NON_NULL (test_long_constant_0);
160 CHECK_VALUE (test_long_constant_0 (), 0);
161
162 test_fn test_long_constant_LONG_MAX =
163 (test_fn)gcc_jit_result_get_code (result,
164 "test_long_constant_LONG_MAX");
165 CHECK_NON_NULL (test_long_constant_LONG_MAX);
166 CHECK_VALUE (test_long_constant_LONG_MAX (), LONG_MAX);
167
168 test_fn test_long_constant_LONG_MIN =
169 (test_fn)gcc_jit_result_get_code (result,
170 "test_long_constant_LONG_MIN");
171 CHECK_NON_NULL (test_long_constant_LONG_MIN);
172 CHECK_VALUE (test_long_constant_LONG_MIN (), LONG_MIN);
173 }
174
175 /**********************************************************************
176 Tests of gcc_jit_context_new_rvalue_from_double.
177 **********************************************************************/
178
179 static const char *
180 make_test_of_double_constant (gcc_jit_context *ctxt,
181 gcc_jit_type *type,
182 double value,
183 const char *funcname)
184 {
185 /* Make a test function of the form:
186 double funcname (void)
187 {
188 return VALUE;
189 }
190 and return a debug dump of VALUE so that
191 the caller can sanity-check the debug dump implementation.
192 */
193 gcc_jit_rvalue *rvalue =
194 gcc_jit_context_new_rvalue_from_double (ctxt, type, value);
195 make_test_of_constant (ctxt, type, rvalue, funcname);
196 return gcc_jit_object_get_debug_string (
197 gcc_jit_rvalue_as_object (rvalue));
198 }
199
200 static void
201 make_tests_of_double_constants (gcc_jit_context *ctxt)
202 {
203 gcc_jit_type *double_type =
204 gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_DOUBLE);
205
206 make_test_of_double_constant (ctxt,
207 double_type,
208 0.5,
209 "test_double_constant_0_5");
210 make_test_of_double_constant (ctxt,
211 double_type,
212 1e100,
213 "test_double_constant_1e100");
214 make_test_of_double_constant (ctxt,
215 double_type,
216 DBL_MIN,
217 "test_double_constant_DBL_MIN");
218 make_test_of_double_constant (ctxt,
219 double_type,
220 DBL_MAX,
221 "test_double_constant_DBL_MAX");
222 }
223
224 static void
225 verify_double_constants (gcc_jit_result *result)
226 {
227 typedef double (*test_fn) (void);
228
229 test_fn test_double_constant_0_5 =
230 (test_fn)gcc_jit_result_get_code (result,
231 "test_double_constant_0_5");
232 CHECK_NON_NULL (test_double_constant_0_5);
233 CHECK_VALUE (test_double_constant_0_5 (), 0.5);
234
235 test_fn test_double_constant_1e100 =
236 (test_fn)gcc_jit_result_get_code (result,
237 "test_double_constant_1e100");
238 CHECK_NON_NULL (test_double_constant_1e100);
239 CHECK_VALUE (test_double_constant_1e100 (), 1e100);
240
241 test_fn test_double_constant_DBL_MIN =
242 (test_fn)gcc_jit_result_get_code (result,
243 "test_double_constant_DBL_MIN");
244 CHECK_NON_NULL (test_double_constant_DBL_MIN);
245 CHECK_VALUE (test_double_constant_DBL_MIN (), DBL_MIN);
246
247 test_fn test_double_constant_DBL_MAX =
248 (test_fn)gcc_jit_result_get_code (result,
249 "test_double_constant_DBL_MAX");
250 CHECK_NON_NULL (test_double_constant_DBL_MAX);
251 CHECK_VALUE (test_double_constant_DBL_MAX (), DBL_MAX);
252 }
253
254 /**********************************************************************
255 Tests of gcc_jit_context_new_rvalue_from_ptr.
256 **********************************************************************/
257
258 static const char *
259 make_test_of_ptr_constant (gcc_jit_context *ctxt,
260 gcc_jit_type *type,
261 void *value,
262 const char *funcname)
263 {
264 /* Make a test function of the form:
265 void *funcname (void)
266 {
267 return VALUE;
268 }
269 and return a debug dump of VALUE so that
270 the caller can sanity-check the debug dump implementation.
271 */
272 gcc_jit_rvalue *rvalue =
273 gcc_jit_context_new_rvalue_from_ptr (ctxt, type, value);
274 make_test_of_constant (ctxt, type, rvalue, funcname);
275 return gcc_jit_object_get_debug_string (
276 gcc_jit_rvalue_as_object (rvalue));
277 }
278
279 static void
280 make_tests_of_ptr_constants (gcc_jit_context *ctxt)
281 {
282 gcc_jit_type *ptr_type =
283 gcc_jit_context_get_type (ctxt, GCC_JIT_TYPE_VOID_PTR);
284
285 CHECK_STRING_VALUE (
286 make_test_of_ptr_constant (ctxt,
287 ptr_type,
288 0,
289 "test_ptr_constant_0"),
290 "(void *)NULL");
291 CHECK_STRING_VALUE (
292 make_test_of_ptr_constant (ctxt,
293 ptr_type,
294 (void *)0xdeadbeef,
295 "test_ptr_constant_0xdeadbeef"),
296 "(void *)0xdeadbeef");
297 }
298
299 static void
300 verify_ptr_constants (gcc_jit_result *result)
301 {
302 typedef void *(*test_fn) (void);
303
304 test_fn test_ptr_constant_0 =
305 (test_fn)gcc_jit_result_get_code (result,
306 "test_ptr_constant_0");
307 CHECK_NON_NULL (test_ptr_constant_0);
308 CHECK_VALUE (test_ptr_constant_0 (), 0);
309
310 test_fn test_ptr_constant_0xdeadbeef =
311 (test_fn)gcc_jit_result_get_code (result,
312 "test_ptr_constant_0xdeadbeef");
313 CHECK_NON_NULL (test_ptr_constant_0xdeadbeef);
314 CHECK_VALUE (test_ptr_constant_0xdeadbeef (), (void *)0xdeadbeef);
315 }
316
317 /**********************************************************************
318 Code for harness
319 **********************************************************************/
320
321 void
322 create_code (gcc_jit_context *ctxt, void *user_data)
323 {
324 make_tests_of_int_constants (ctxt);
325 make_tests_of_long_constants (ctxt);
326 make_tests_of_double_constants (ctxt);
327 make_tests_of_ptr_constants (ctxt);
328 }
329
330 void
331 verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
332 {
333 CHECK_NON_NULL (result);
334
335 verify_int_constants (result);
336 verify_long_constants (result);
337 verify_double_constants (result);
338 verify_ptr_constants (result);
339 }