gcc/testsuite/jit.dg/harness.h

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