1 /*
2 Code shared between multiple testcases.
3
4 This file contains "main" and support code.
5 Each testcase should implement the following hooks:
6
7 extern void
8 create_code (gcc_jit_context *ctxt, void * user_data);
9
10 and, #ifndef TEST_COMPILING_TO_FILE,
11
12 extern void
13 verify_code (gcc_jit_context *ctxt, gcc_jit_result *result);
14 */
15 #include <stdlib.h>
16 #include <stdio.h>
17 #include <unistd.h>
18
19 /* test-threads.c use threads, but dejagnu.h isn't thread-safe; there's a
20 shared "buffer", and the counts of passed/failed etc are globals.
21
22 The solution is to use macros to rename "pass" and "fail", replacing them
23 with mutex-guarded alternatives. */
24 #ifdef MAKE_DEJAGNU_H_THREADSAFE
25 #define pass dejagnu_pass
26 #define fail dejagnu_fail
27 #define note dejagnu_note
28 #endif
29
30 #include "jit-dejagnu.h"
31
32 #ifdef MAKE_DEJAGNU_H_THREADSAFE
33 #undef pass
34 #undef fail
35 #undef note
36 #endif
37
38 static char test[1024];
39
40 #define CHECK_NON_NULL(PTR) \
41 do { \
42 if ((PTR) != NULL) \
43 { \
44 pass ("%s: %s: %s is non-null", \
45 test, __func__, #PTR); \
46 } \
47 else \
48 { \
49 fail ("%s: %s: %s is NULL", \
50 test, __func__, #PTR); \
51 abort (); \
52 } \
53 } while (0)
54
55 #define CHECK_VALUE(ACTUAL, EXPECTED) \
56 do { \
57 if ((ACTUAL) == (EXPECTED)) \
58 { \
59 pass ("%s: %s: actual: %s == expected: %s", \
60 test, __func__, #ACTUAL, #EXPECTED); \
61 } \
62 else \
63 { \
64 fail ("%s: %s: actual: %s != expected: %s", \
65 test, __func__, #ACTUAL, #EXPECTED); \
66 fprintf (stderr, "incorrect value\n"); \
67 abort (); \
68 } \
69 } while (0)
70
71 #define CHECK_VECTOR_VALUE(LEN, ACTUAL, EXPECTED) \
72 do { \
73 for (int __check_vector_it = 0; __check_vector_it < LEN; ++__check_vector_it) { \
74 if ((ACTUAL)[__check_vector_it] != (EXPECTED)[__check_vector_it]) { \
75 fail ("%s: %s: actual: %s != expected: %s (position %d)", \
76 test, __func__, #ACTUAL, #EXPECTED, __check_vector_it); \
77 fprintf (stderr, "incorrect value\n"); \
78 abort (); \
79 } \
80 } \
81 pass ("%s: %s: actual: %s == expected: %s", \
82 test, __func__, #ACTUAL, #EXPECTED); \
83 } while (0)
84
85
86 #define CHECK_DOUBLE_VALUE(ACTUAL, EXPECTED) \
87 do { \
88 double expected = (EXPECTED); \
89 double actual = (ACTUAL); \
90 if (abs (actual - expected) < 0.00001) \
91 { \
92 pass ("%s: %s: actual: %s == expected: %s", \
93 __func__, test, #ACTUAL, #EXPECTED); \
94 } \
95 else \
96 { \
97 fail ("%s: %s: actual: %s != expected: %s", \
98 __func__, test, #ACTUAL, #EXPECTED); \
99 fprintf (stderr, "incorrect value: %f\n", actual); \
100 abort (); \
101 } \
102 } while (0)
103
104 #define CHECK_STRING_VALUE(ACTUAL, EXPECTED) \
105 check_string_value (__func__, (ACTUAL), (EXPECTED));
106
107 #define CHECK_STRING_STARTS_WITH(ACTUAL, EXPECTED_PREFIX) \
108 check_string_starts_with (__func__, (ACTUAL), (EXPECTED_PREFIX));
109
110 #define CHECK_STRING_CONTAINS(ACTUAL, EXPECTED_SUBSTRING) \
111 check_string_contains (__func__, #ACTUAL, (ACTUAL), (EXPECTED_SUBSTRING));
112
113 #define CHECK(COND) \
114 do { \
115 if (COND) \
116 { \
117 pass ("%s: %s: %s", test, __func__, #COND); \
118 } \
119 else \
120 { \
121 fail ("%s: %s: %s", test, __func__, #COND); \
122 abort (); \
123 } \
124 } while (0)
125
126 #define CHECK_NO_ERRORS(CTXT) \
127 do { \
128 const char *err = gcc_jit_context_get_first_error (CTXT); \
129 if (err) \
130 fail ("%s: %s: error unexpectedly occurred: %s", test, __func__, err); \
131 else \
132 pass ("%s: %s: no errors occurred", test, __func__); \
133 } while (0)
134
135 /* Hooks that testcases should provide. */
136 extern void
137 create_code (gcc_jit_context *ctxt, void * user_data);
138
139 #ifndef TEST_COMPILING_TO_FILE
140 extern void
141 verify_code (gcc_jit_context *ctxt, gcc_jit_result *result);
142 #endif
143
144 extern void check_string_value (const char *funcname,
145 const char *actual, const char *expected);
146
147 extern void
148 check_string_starts_with (const char *funcname,
149 const char *actual,
150 const char *expected_prefix);
151
152 extern void
153 check_string_contains (const char *funcname,
154 const char *name,
155 const char *actual,
156 const char *expected_substring);
157
158 /* Implement framework needed for turning the testcase hooks into an
159 executable. test-combination.c and test-threads.c each combine multiple
160 testcases into larger testcases, so we have COMBINED_TEST as a way of
161 temporarily turning off this part of harness.h. */
162 #ifndef COMBINED_TEST
163
164 void check_string_value (const char *funcname,
165 const char *actual, const char *expected)
166 {
167 if (actual && !expected)
168 {
169 fail ("%s: %s: actual: \"%s\" != expected: NULL",
170 funcname, test, actual);
171 fprintf (stderr, "incorrect value\n");
172 abort ();
173 }
174 if (expected && !actual)
175 {
176 fail ("%s: %s: actual: NULL != expected: \"%s\"",
177 funcname, test, expected);
178 fprintf (stderr, "incorrect value\n");
179 abort ();
180 }
181 if (actual && expected)
182 {
183 if (strcmp (actual, expected))
184 {
185 fail ("%s: %s: actual: \"%s\" != expected: \"%s\"",
186 test, funcname, actual, expected);
187 fprintf (stderr, "incorrect valuen");
188 abort ();
189 }
190 pass ("%s: %s: actual: \"%s\" == expected: \"%s\"",
191 test, funcname, actual, expected);
192 }
193 else
194 pass ("%s: actual: NULL == expected: NULL");
195 }
196
197 void
198 check_string_starts_with (const char *funcname,
199 const char *actual,
200 const char *expected_prefix)
201 {
202 if (!actual)
203 {
204 fail ("%s: %s: actual: NULL != expected prefix: \"%s\"",
205 test, funcname, expected_prefix);
206 fprintf (stderr, "incorrect value\n");
207 abort ();
208 }
209
210 if (strncmp (actual, expected_prefix, strlen (expected_prefix)))
211 {
212 fail ("%s: %s: actual: \"%s\" did not begin with expected prefix: \"%s\"",
213 test, funcname, actual, expected_prefix);
214 fprintf (stderr, "incorrect value\n");
215 abort ();
216 }
217
218 pass ("%s: actual: \"%s\" begins with expected prefix: \"%s\"",
219 test, actual, expected_prefix);
220 }
221
222 void
223 check_string_contains (const char *funcname,
224 const char *name,
225 const char *actual,
226 const char *expected_substring)
227 {
228 if (!actual)
229 {
230 fail ("%s: %s, %s: actual: NULL does not contain expected substring: \"%s\"",
231 test, funcname, name, expected_substring);
232 fprintf (stderr, "incorrect value\n");
233 abort ();
234 }
235
236 if (!strstr (actual, expected_substring))
237 {
238 fail ("%s: %s: %s: actual: \"%s\" did not contain expected substring: \"%s\"",
239 test, funcname, name, actual, expected_substring);
240 fprintf (stderr, "incorrect value\n");
241 abort ();
242 }
243
244 pass ("%s: %s: %s: found substring: \"%s\"",
245 test, funcname, name, expected_substring);
246 }
247
248 #ifndef TEST_ESCHEWS_SET_OPTIONS
249 static void set_options (gcc_jit_context *ctxt, const char *argv0)
250 {
251 /* Set up options. */
252 gcc_jit_context_set_str_option (
253 ctxt,
254 GCC_JIT_STR_OPTION_PROGNAME,
255 argv0);
256 gcc_jit_context_set_int_option (
257 ctxt,
258 GCC_JIT_INT_OPTION_OPTIMIZATION_LEVEL,
259 3);
260 gcc_jit_context_set_bool_option (
261 ctxt,
262 GCC_JIT_BOOL_OPTION_DEBUGINFO,
263 1);
264 gcc_jit_context_set_bool_option (
265 ctxt,
266 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_TREE,
267 0);
268 gcc_jit_context_set_bool_option (
269 ctxt,
270 GCC_JIT_BOOL_OPTION_DUMP_INITIAL_GIMPLE,
271 0);
272 gcc_jit_context_set_bool_option (
273 ctxt,
274 GCC_JIT_BOOL_OPTION_SELFCHECK_GC,
275 1);
276 gcc_jit_context_set_bool_option (
277 ctxt,
278 GCC_JIT_BOOL_OPTION_DUMP_SUMMARY,
279 0);
280 /* Make it easier to compare error messages by disabling colorization,
281 rather then have them be affected by whether stderr is going to a tty. */
282 gcc_jit_context_add_command_line_option
283 (ctxt, "-fdiagnostics-color=never");
284 }
285 #endif /* #ifndef TEST_ESCHEWS_SET_OPTIONS */
286
287 /* Concatenate two strings. The result must be released using "free". */
288
289 char *
290 concat_strings (const char *prefix, const char *suffix)
291 {
292 char *result = (char *)malloc (strlen (prefix) + strlen (suffix) + 1);
293 if (!result)
294 {
295 fail ("malloc failure");
296 return NULL;
297 }
298 strcpy (result, prefix);
299 strcpy (result + strlen (prefix), suffix);
300 result[strlen (prefix) + strlen (suffix)] = '\0';
301 return result;
302 }
303
304 #ifndef TEST_ESCHEWS_TEST_JIT
305 /* Set up logging to a logfile of the form "test-FOO.exe.log.txt".
306
307 For example,
308 SRCDIR/gcc/testsuite/jit.dg/test-hello-world.c
309 is built as:
310 BUILDDIR/gcc/testsuite/jit/test-hello-world.c.exe
311 and is logged to
312 BUILDDIR/gcc/testsuite/jit/test-hello-world.c.exe.log.txt
313
314 The logfile must be closed by the caller.
315
316 Note that not every testcase enables logging. */
317 static FILE *
318 set_up_logging (gcc_jit_context *ctxt, const char *argv0)
319 {
320 const char *logfile_name_suffix = ".log.txt";
321 char *logfile_name = NULL;
322 FILE *logfile = NULL;
323
324 /* Build a logfile name of the form "test-FOO.exe.log.txt". */
325 logfile_name = concat_strings (argv0, logfile_name_suffix);
326 if (!logfile_name)
327 return NULL;
328 logfile = fopen (logfile_name, "w");
329 CHECK_NON_NULL (logfile);
330 free (logfile_name);
331
332 if (logfile)
333 gcc_jit_context_set_logfile (ctxt, logfile, 0, 0);
334
335 return logfile;
336 }
337
338 /* Exercise the API entrypoint:
339 gcc_jit_context_dump_reproducer_to_file
340 by calling it on the context, using the path expected by jit.exp. */
341 static void
342 dump_reproducer (gcc_jit_context *ctxt, const char *argv0)
343 {
344 char *reproducer_name;
345 reproducer_name = concat_strings (argv0, ".reproducer.c");
346 if (!reproducer_name)
347 return;
348 note ("%s: writing reproducer to %s", test, reproducer_name);
349 gcc_jit_context_dump_reproducer_to_file (ctxt, reproducer_name);
350 free (reproducer_name);
351 }
352
353 /* Run one iteration of the test. */
354 static void
355 test_jit (const char *argv0, void *user_data)
356 {
357 gcc_jit_context *ctxt;
358 FILE *logfile;
359 #ifndef TEST_COMPILING_TO_FILE
360 gcc_jit_result *result;
361 #endif
362
363 #ifdef TEST_COMPILING_TO_FILE
364 unlink (OUTPUT_FILENAME);
365 #endif
366
367 ctxt = gcc_jit_context_acquire ();
368 if (!ctxt)
369 {
370 fail ("gcc_jit_context_acquire failed");
371 return;
372 }
373
374 logfile = set_up_logging (ctxt, argv0);
375
376 set_options (ctxt, argv0);
377
378 create_code (ctxt, user_data);
379
380 dump_reproducer (ctxt, argv0);
381
382 #ifdef TEST_COMPILING_TO_FILE
383 gcc_jit_context_compile_to_file (ctxt,
384 (OUTPUT_KIND),
385 (OUTPUT_FILENAME));
386 CHECK_NO_ERRORS (ctxt);
387 #else /* #ifdef TEST_COMPILING_TO_FILE */
388 /* This actually calls into GCC and runs the build, all
389 in a mutex for now. */
390 result = gcc_jit_context_compile (ctxt);
391
392 verify_code (ctxt, result);
393 #endif
394
395 gcc_jit_context_release (ctxt);
396
397 #ifndef TEST_COMPILING_TO_FILE
398 /* Once we're done with the code, this unloads the built .so file: */
399 gcc_jit_result_release (result);
400 #endif
401
402 if (logfile)
403 fclose (logfile);
404 }
405 #endif /* #ifndef TEST_ESCHEWS_TEST_JIT */
406
407 /* We want to prefix all unit test results with the test, but dejagnu.exp's
408 host_execute appears to get confused by the leading "./" of argv0,
409 leading to all tests simply reporting as a single period character ".".
410
411 Hence strip out the final component of the path to the program name,
412 so that we can use that in unittest reports. */
413 const char*
414 extract_progname (const char *argv0)
415 {
416 const char *p;
417
418 p = argv0 + strlen (argv0);
419 while (p != argv0 && p[-1] != '/')
420 --p;
421 return p;
422 }
423
424 #ifndef TEST_PROVIDES_MAIN
425 int
426 main (int argc, char **argv)
427 {
428 int i;
429
430 for (i = 1; i <= 5; i++)
431 {
432 snprintf (test, sizeof (test),
433 "%s iteration %d of %d",
434 extract_progname (argv[0]),
435 i, 5);
436
437 //printf ("ITERATION %d\n", i);
438 test_jit (argv[0], NULL);
439 //printf ("\n");
440 }
441
442 totals ();
443
444 return 0;
445 }
446 #endif /* #ifndef TEST_PROVIDES_MAIN */
447
448 #endif /* #ifndef COMBINED_TEST */