1 #include <stdlib.h>
2 #include <stdio.h>
3
4 #include "libgccjit.h"
5
6 #include "harness.h"
7
8 struct quadratic
9 {
10 double a;
11 double b;
12 double c;
13 double discriminant;
14 };
15
16 /* Let's try to inject the equivalent of:
17
18 extern double sqrt (double);
19
20 static void
21 calc_discriminant (struct quadratic *q)
22 {
23 // (b^2 - 4ac)
24 q->discriminant = (q->b * q->b) - (4 * q->a * q->c);
25 }
26
27 int
28 test_quadratic (double a, double b, double c, double *r1, double *r2)
29 {
30 struct quadratic q;
31 q.a = a;
32 q.b = b;
33 q.c = c;
34 calc_discriminant (&q);
35 if (q.discriminant > 0)
36 {
37 double s = sqrt (q.discriminant);
38 *r1 = (-b + s) / (2 * a);
39 *r2 = (-b - s) / (2 * a);
40 return 2;
41 }
42 else if (q.discriminant == 0)
43 {
44 *r1 = -b / (2 * a);
45 return 1;
46 }
47 else return 0;
48 }
49 */
50
51 struct quadratic_test
52 {
53 gcc_jit_context *ctxt;
54
55 /* "double" and "(double *)". */
56 gcc_jit_type *numeric_type;
57 gcc_jit_type *numeric_type_ptr;
58
59 /* The value (double)0. */
60 gcc_jit_rvalue *zero;
61
62 gcc_jit_type *int_type;
63 gcc_jit_type *void_type;
64
65 /* "struct quadratic" */
66 gcc_jit_type *quadratic;
67 gcc_jit_field *a;
68 gcc_jit_field *b;
69 gcc_jit_field *c;
70 gcc_jit_field *discriminant;
71
72 /* "(struct quadratic *)" */
73 gcc_jit_type *quadratic_ptr;
74
75 gcc_jit_function *calc_discriminant;
76
77 gcc_jit_function *sqrt;
78
79 };
80
81 static void
82 make_types (struct quadratic_test *testcase)
83 {
84 testcase->numeric_type =
85 gcc_jit_context_get_type (testcase->ctxt, GCC_JIT_TYPE_DOUBLE);
86 testcase->numeric_type_ptr =
87 gcc_jit_type_get_pointer (testcase->numeric_type);
88 testcase->zero =
89 gcc_jit_context_zero (testcase->ctxt, testcase->numeric_type);
90
91 testcase->int_type =
92 gcc_jit_context_get_type (testcase->ctxt, GCC_JIT_TYPE_INT);
93
94 testcase->void_type =
95 gcc_jit_context_get_type (testcase->ctxt, GCC_JIT_TYPE_VOID);
96
97 testcase->a =
98 gcc_jit_context_new_field (testcase->ctxt,
99 NULL,
100 testcase->numeric_type,
101 "a");
102 testcase->b =
103 gcc_jit_context_new_field (testcase->ctxt,
104 NULL,
105 testcase->numeric_type,
106 "b");
107 testcase->c =
108 gcc_jit_context_new_field (testcase->ctxt,
109 NULL,
110 testcase->numeric_type,
111 "c");
112 testcase->discriminant =
113 gcc_jit_context_new_field (testcase->ctxt,
114 NULL,
115 testcase->numeric_type,
116 "discriminant");
117 gcc_jit_field *fields[] = {testcase->a,
118 testcase->b,
119 testcase->c,
120 testcase->discriminant};
121 testcase->quadratic =
122 gcc_jit_struct_as_type (
123 gcc_jit_context_new_struct_type (testcase->ctxt, NULL,
124 "quadratic", 4, fields));
125 testcase->quadratic_ptr = gcc_jit_type_get_pointer (testcase->quadratic);
126 }
127
128 static void
129 make_sqrt (struct quadratic_test *testcase)
130 {
131 gcc_jit_param *param_x =
132 gcc_jit_context_new_param (testcase->ctxt, NULL,
133 testcase->numeric_type, "x");
134 testcase->sqrt =
135 gcc_jit_context_new_function (testcase->ctxt, NULL,
136 GCC_JIT_FUNCTION_IMPORTED,
137 testcase->numeric_type,
138 "sqrt",
139 1, ¶m_x,
140 0);
141 }
142
143 static void
144 make_calc_discriminant (struct quadratic_test *testcase)
145 {
146 /* Build "calc_discriminant". */
147 gcc_jit_param *param_q =
148 gcc_jit_context_new_param (testcase->ctxt, NULL,
149 testcase->quadratic_ptr, "q");
150 testcase->calc_discriminant =
151 gcc_jit_context_new_function (testcase->ctxt, NULL,
152 GCC_JIT_FUNCTION_INTERNAL,
153 testcase->void_type,
154 "calc_discriminant",
155 1, ¶m_q,
156 0);
157 gcc_jit_block *blk =
158 gcc_jit_function_new_block (testcase->calc_discriminant, NULL);
159 gcc_jit_block_add_comment (
160 blk, NULL,
161 "(b^2 - 4ac)");
162
163 gcc_jit_rvalue *q_a =
164 gcc_jit_lvalue_as_rvalue (
165 gcc_jit_rvalue_dereference_field (
166 gcc_jit_param_as_rvalue (param_q),
167 NULL, testcase->a));
168 gcc_jit_rvalue *q_b =
169 gcc_jit_lvalue_as_rvalue (
170 gcc_jit_rvalue_dereference_field (
171 gcc_jit_param_as_rvalue (param_q),
172 NULL, testcase->b));
173 gcc_jit_rvalue *q_c =
174 gcc_jit_lvalue_as_rvalue (
175 gcc_jit_rvalue_dereference_field (
176 gcc_jit_param_as_rvalue (param_q),
177 NULL, testcase->c));
178
179 /* (q->b * q->b) - (4 * q->a * q->c) */
180 gcc_jit_rvalue *rhs =
181 gcc_jit_context_new_binary_op (
182 testcase->ctxt, NULL,
183 GCC_JIT_BINARY_OP_MINUS,
184 testcase->numeric_type,
185
186 /* (q->b * q->b) */
187 gcc_jit_context_new_binary_op (
188 testcase->ctxt, NULL,
189 GCC_JIT_BINARY_OP_MULT,
190 testcase->numeric_type,
191 q_b, q_b),
192
193 /* (4 * (q->a * q->c)) */
194 gcc_jit_context_new_binary_op (
195 testcase->ctxt, NULL,
196 GCC_JIT_BINARY_OP_MULT,
197 testcase->numeric_type,
198 /* 4.0 */
199 gcc_jit_context_new_rvalue_from_int (
200 testcase->ctxt,
201 testcase->numeric_type,
202 4),
203 /* (q->a * q->c) */
204 gcc_jit_context_new_binary_op (
205 testcase->ctxt, NULL,
206 GCC_JIT_BINARY_OP_MULT,
207 testcase->numeric_type,
208 q_a, q_c)));
209
210 CHECK_STRING_VALUE (
211 gcc_jit_object_get_debug_string (gcc_jit_rvalue_as_object (rhs)),
212 "q->b * q->b - (double)4 * q->a * q->c");
213
214 gcc_jit_block_add_assignment (
215 blk, NULL,
216
217 /* q->discriminant =... */
218 gcc_jit_rvalue_dereference_field (
219 gcc_jit_param_as_rvalue (param_q),
220 NULL,
221 testcase->discriminant),
222 rhs);
223
224 gcc_jit_block_end_with_void_return (blk, NULL);
225 }
226
227 static void
228 make_test_quadratic (struct quadratic_test *testcase)
229 {
230 gcc_jit_param *a =
231 gcc_jit_context_new_param (testcase->ctxt, NULL,
232 testcase->numeric_type, "a");
233 gcc_jit_param *b =
234 gcc_jit_context_new_param (testcase->ctxt, NULL,
235 testcase->numeric_type, "b");
236 gcc_jit_param *c =
237 gcc_jit_context_new_param (testcase->ctxt, NULL,
238 testcase->numeric_type, "c");
239 gcc_jit_param *r1 =
240 gcc_jit_context_new_param (testcase->ctxt, NULL,
241 testcase->numeric_type_ptr, "r1");
242 gcc_jit_param *r2 =
243 gcc_jit_context_new_param (testcase->ctxt, NULL,
244 testcase->numeric_type_ptr, "r2");
245 gcc_jit_param *params[] = {a, b, c, r1, r2};
246 gcc_jit_function *test_quadratic =
247 gcc_jit_context_new_function (testcase->ctxt, NULL,
248 GCC_JIT_FUNCTION_EXPORTED,
249 testcase->int_type,
250 "test_quadratic",
251 5, params,
252 0);
253 /* struct quadratic q; */
254 gcc_jit_lvalue *q =
255 gcc_jit_function_new_local (
256 test_quadratic, NULL,
257 testcase->quadratic,
258 "q");
259
260 gcc_jit_block *initial =
261 gcc_jit_function_new_block (test_quadratic,
262 "initial");
263 gcc_jit_block *on_positive_discriminant
264 = gcc_jit_function_new_block (test_quadratic,
265 "positive_discriminant");
266
267 gcc_jit_block *on_nonpositive_discriminant
268 = gcc_jit_function_new_block (test_quadratic,
269 "nonpositive_discriminant");
270
271 gcc_jit_block *on_zero_discriminant
272 = gcc_jit_function_new_block (test_quadratic,
273 "zero_discriminant");
274
275 gcc_jit_block *on_negative_discriminant
276 = gcc_jit_function_new_block (test_quadratic,
277 "negative_discriminant");
278
279 /* Initial block. */
280 /* q.a = a; */
281 gcc_jit_block_add_assignment (
282 initial, NULL,
283 gcc_jit_lvalue_access_field (q, NULL, testcase->a),
284 gcc_jit_param_as_rvalue (a));
285 /* q.b = b; */
286 gcc_jit_block_add_assignment (
287 initial, NULL,
288 gcc_jit_lvalue_access_field (q, NULL, testcase->b),
289 gcc_jit_param_as_rvalue (b));
290 /* q.c = c; */
291 gcc_jit_block_add_assignment (
292 initial, NULL,
293 gcc_jit_lvalue_access_field (q, NULL, testcase->c),
294 gcc_jit_param_as_rvalue (c));
295 /* calc_discriminant (&q); */
296 gcc_jit_rvalue *address_of_q = gcc_jit_lvalue_get_address (q, NULL);
297 gcc_jit_block_add_eval (
298 initial, NULL,
299 gcc_jit_context_new_call (
300 testcase->ctxt, NULL,
301 testcase->calc_discriminant,
302 1, &address_of_q));
303
304 gcc_jit_block_add_comment (
305 initial, NULL,
306 "if (q.discriminant > 0)");
307 gcc_jit_block_end_with_conditional (
308 initial, NULL,
309 gcc_jit_context_new_comparison (
310 testcase->ctxt, NULL,
311 GCC_JIT_COMPARISON_GT,
312 gcc_jit_rvalue_access_field (
313 gcc_jit_lvalue_as_rvalue (q),
314 NULL,
315 testcase->discriminant),
316 testcase->zero),
317 on_positive_discriminant,
318 on_nonpositive_discriminant);
319
320 /* Block: "on_positive_discriminant" */
321 /* double s = sqrt (q.discriminant); */
322 gcc_jit_lvalue *s = gcc_jit_function_new_local (
323 test_quadratic, NULL,
324 testcase->numeric_type,
325 "s");
326 gcc_jit_rvalue *discriminant_of_q =
327 gcc_jit_rvalue_access_field (gcc_jit_lvalue_as_rvalue (q),
328 NULL,
329 testcase->discriminant);
330 gcc_jit_block_add_assignment (
331 on_positive_discriminant, NULL,
332 s,
333 gcc_jit_context_new_call (
334 testcase->ctxt, NULL,
335 testcase->sqrt,
336 1, &discriminant_of_q));
337
338 gcc_jit_rvalue *minus_b =
339 gcc_jit_context_new_unary_op (
340 testcase->ctxt, NULL,
341 GCC_JIT_UNARY_OP_MINUS,
342 testcase->numeric_type,
343 gcc_jit_param_as_rvalue (b));
344 gcc_jit_rvalue *two_a =
345 gcc_jit_context_new_binary_op (
346 testcase->ctxt, NULL,
347 GCC_JIT_BINARY_OP_MULT,
348 testcase->numeric_type,
349 gcc_jit_context_new_rvalue_from_int (
350 testcase->ctxt,
351 testcase->numeric_type,
352 2),
353 gcc_jit_param_as_rvalue (a));
354
355 gcc_jit_block_add_comment (
356 on_positive_discriminant, NULL,
357 "*r1 = (-b + s) / (2 * a);");
358 gcc_jit_block_add_assignment (
359 on_positive_discriminant, NULL,
360
361 /* "*r1 = ..." */
362 gcc_jit_rvalue_dereference (
363 gcc_jit_param_as_rvalue (r1), NULL),
364
365 /* (-b + s) / (2 * a) */
366 gcc_jit_context_new_binary_op (
367 testcase->ctxt, NULL,
368 GCC_JIT_BINARY_OP_DIVIDE,
369 testcase->numeric_type,
370 gcc_jit_context_new_binary_op (
371 testcase->ctxt, NULL,
372 GCC_JIT_BINARY_OP_PLUS,
373 testcase->numeric_type,
374 minus_b,
375 gcc_jit_lvalue_as_rvalue (s)),
376 two_a));
377
378 gcc_jit_block_add_comment (
379 on_positive_discriminant, NULL,
380 "*r2 = (-b - s) / (2 * a)");
381 gcc_jit_block_add_assignment (
382 on_positive_discriminant, NULL,
383
384 /* "*r2 = ..." */
385 gcc_jit_rvalue_dereference (
386 gcc_jit_param_as_rvalue (r2), NULL),
387
388 /* (-b - s) / (2 * a) */
389 gcc_jit_context_new_binary_op (
390 testcase->ctxt, NULL,
391 GCC_JIT_BINARY_OP_DIVIDE,
392 testcase->numeric_type,
393 gcc_jit_context_new_binary_op (
394 testcase->ctxt, NULL,
395 GCC_JIT_BINARY_OP_MINUS,
396 testcase->numeric_type,
397 minus_b,
398 gcc_jit_lvalue_as_rvalue (s)),
399 two_a));
400
401 /* "return 2;" */
402 gcc_jit_block_end_with_return (
403 on_positive_discriminant, NULL,
404 gcc_jit_context_new_rvalue_from_int (
405 testcase->ctxt,
406 testcase->int_type,
407 2));
408
409 /* Block: "on_nonpositive_discriminant" */
410 gcc_jit_block_add_comment (
411 on_nonpositive_discriminant, NULL,
412 "else if (q.discriminant == 0)");
413 gcc_jit_block_end_with_conditional (
414 on_nonpositive_discriminant, NULL,
415 gcc_jit_context_new_comparison (
416 testcase->ctxt, NULL,
417 GCC_JIT_COMPARISON_EQ,
418 gcc_jit_rvalue_access_field (
419 gcc_jit_lvalue_as_rvalue (q),
420 NULL,
421 testcase->discriminant),
422 testcase->zero),
423 on_zero_discriminant,
424 on_negative_discriminant);
425
426 /* Block: "on_zero_discriminant" */
427 gcc_jit_block_add_comment (
428 on_zero_discriminant, NULL,
429 "*r1 = -b / (2 * a);");
430 gcc_jit_block_add_assignment (
431 on_zero_discriminant, NULL,
432
433 /* "*r1 = ..." */
434 gcc_jit_rvalue_dereference (
435 gcc_jit_param_as_rvalue (r1), NULL),
436
437 /* -b / (2 * a) */
438 gcc_jit_context_new_binary_op (
439 testcase->ctxt, NULL,
440 GCC_JIT_BINARY_OP_DIVIDE,
441 testcase->numeric_type,
442 minus_b,
443 two_a));
444 gcc_jit_block_end_with_return (
445 /* "return 1;" */
446 on_zero_discriminant, NULL,
447 gcc_jit_context_one (testcase->ctxt, testcase->int_type));
448
449 /* Block: "on_negative_discriminant" */
450 gcc_jit_block_end_with_return (
451 /* "else return 0;" */
452 on_negative_discriminant, NULL,
453 gcc_jit_context_zero (testcase->ctxt, testcase->int_type));
454 }
455
456 void
457 create_code (gcc_jit_context *ctxt, void *user_data)
458 {
459 struct quadratic_test testcase;
460 memset (&testcase, 0, sizeof (testcase));
461 testcase.ctxt = ctxt;
462 make_types (&testcase);
463 make_sqrt (&testcase);
464 make_calc_discriminant (&testcase);
465 make_test_quadratic (&testcase);
466 }
467
468 void
469 verify_code (gcc_jit_context *ctxt, gcc_jit_result *result)
470 {
471 typedef int (*fn_type) (double a, double b, double c,
472 double *r1, double *r2);
473
474 CHECK_NON_NULL (result);
475
476 fn_type test_quadratic =
477 (fn_type)gcc_jit_result_get_code (result, "test_quadratic");
478 CHECK_NON_NULL (test_quadratic);
479
480 /* Verify that the code correctly solves quadratic equations. */
481 double r1, r2;
482
483 /* This one has two solutions: */
484 CHECK_VALUE (test_quadratic (1, 3, -4, &r1, &r2), 2);
485 CHECK_VALUE (r1, 1);
486 CHECK_VALUE (r2, -4);
487
488 /* This one has one solution: */
489 CHECK_VALUE (test_quadratic (4, 4, 1, &r1, &r2), 1);
490 CHECK_VALUE (r1, -0.5);
491
492 /* This one has no real solutions: */
493 CHECK_VALUE (test_quadratic (4, 1, 1, &r1, &r2), 0);
494 }