gcc/selftest.h

   1 /* A self-testing framework, for use by -fself-test.
   2    Copyright (C) 2015-2024 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef GCC_SELFTEST_H
  21 #define GCC_SELFTEST_H
  22
  23 /* The selftest code should entirely disappear in a production
  24    configuration, hence we guard all of it with #if CHECKING_P.  */
  25
  26 #if CHECKING_P
  27
  28 class file_cache;
  29
  30 namespace selftest {
  31
  32 /* A struct describing the source-location of a selftest, to make it
  33    easier to track down failing tests.  */
  34
  35 class location
  36 {
  37 public:
  38   location (const char *file, int line, const char *function)
  39     : m_file (file), m_line (line), m_function (function) {}
  40
  41   const char *m_file;
  42   int m_line;
  43   const char *m_function;
  44 };
  45
  46 /* A macro for use in selftests and by the ASSERT_ macros below,
  47    constructing a selftest::location for the current source location.  */
  48
  49 #define SELFTEST_LOCATION \
  50   (::selftest::location (__FILE__, __LINE__, __FUNCTION__))
  51
  52 /* The entrypoint for running all tests.  */
  53
  54 extern void run_tests ();
  55
  56 /* Record the successful outcome of some aspect of the test.  */
  57
  58 extern void pass (const location &loc, const char *msg);
  59
  60 /* Report the failed outcome of some aspect of the test and abort.  */
  61
  62 extern void fail (const location &loc, const char *msg)
  63   ATTRIBUTE_NORETURN;
  64
  65 /* As "fail", but using printf-style formatted output.  */
  66
  67 extern void fail_formatted (const location &loc, const char *fmt, ...)
  68   ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
  69
  70 /* Implementation detail of ASSERT_STREQ.  */
  71
  72 extern void assert_streq (const location &loc,
  73                           const char *desc_val1, const char *desc_val2,
  74                           const char *val1, const char *val2);
  75
  76 /* Implementation detail of ASSERT_STR_CONTAINS.  */
  77
  78 extern void assert_str_contains (const location &loc,
  79                                  const char *desc_haystack,
  80                                  const char *desc_needle,
  81                                  const char *val_haystack,
  82                                  const char *val_needle);
  83
  84 /* Implementation detail of ASSERT_STR_STARTSWITH.  */
  85
  86 extern void assert_str_startswith (const location &loc,
  87                                    const char *desc_str,
  88                                    const char *desc_prefix,
  89                                    const char *val_str,
  90                                    const char *val_prefix);
  91
  92
  93 /* A named temporary file for use in selftests.
  94    Usable for writing out files, and as the base class for
  95    temp_source_file.
  96    The file is unlinked in the destructor.
  97    If the file_cache is non-null, the filename is evicted from
  98    the file_cache when the named_temp_file is destroyed.  */
  99
 100 class named_temp_file
 101 {
 102  public:
 103   named_temp_file (const char *suffix, file_cache *fc = nullptr);
 104   ~named_temp_file ();
 105   const char *get_filename () const { return m_filename; }
 106
 107  private:
 108   char *m_filename;
 109   file_cache *m_file_cache;
 110 };
 111
 112 /* A class for writing out a temporary sourcefile for use in selftests
 113    of input handling.  */
 114
 115 class temp_source_file : public named_temp_file
 116 {
 117  public:
 118   temp_source_file (const location &loc, const char *suffix,
 119                     const char *content, file_cache *fc = nullptr);
 120   temp_source_file (const location &loc, const char *suffix,
 121                     const char *content, size_t sz);
 122 };
 123
 124 /* RAII-style class for avoiding introducing locale-specific differences
 125    in strings containing localized quote marks, by temporarily overriding
 126    the "open_quote" and "close_quote" globals to something hardcoded.
 127
 128    Specifically, the C locale's values are used:
 129    - open_quote becomes "`"
 130    - close_quote becomes "'"
 131    for the lifetime of the object.  */
 132
 133 class auto_fix_quotes
 134 {
 135  public:
 136   auto_fix_quotes ();
 137   ~auto_fix_quotes ();
 138
 139  private:
 140   const char *m_saved_open_quote;
 141   const char *m_saved_close_quote;
 142 };
 143
 144 /* Various selftests involving location-handling require constructing a
 145    line table and one or more line maps within it.
 146
 147    For maximum test coverage we want to run these tests with a variety
 148    of situations:
 149    - line_table->default_range_bits: some frontends use a non-zero value
 150    and others use zero
 151    - the fallback modes within line-map.cc: there are various threshold
 152    values for location_t beyond line-map.cc changes
 153    behavior (disabling of the range-packing optimization, disabling
 154    of column-tracking).  We can exercise these by starting the line_table
 155    at interesting values at or near these thresholds.
 156
 157    The following struct describes a particular case within our test
 158    matrix.  */
 159
 160 class line_table_case;
 161
 162 /* A class for overriding the global "line_table" within a selftest,
 163    restoring its value afterwards.  At most one instance of this
 164    class can exist at once, due to the need to keep the old value
 165    of line_table as a GC root.  */
 166
 167 class line_table_test
 168 {
 169  public:
 170   /* Default constructor.  Override "line_table", using sane defaults
 171      for the temporary line_table.  */
 172   line_table_test ();
 173
 174   /* Constructor.  Override "line_table", using the case described by C.  */
 175   line_table_test (const line_table_case &c);
 176
 177   /* Destructor.  Restore the saved line_table.  */
 178   ~line_table_test ();
 179 };
 180
 181 /* Helper function for selftests that need a function decl.  */
 182
 183 extern tree make_fndecl (tree return_type,
 184                          const char *name,
 185                          vec <tree> &param_types,
 186                          bool is_variadic = false);
 187
 188 /* Run TESTCASE multiple times, once for each case in our test matrix.  */
 189
 190 extern void
 191 for_each_line_table_case (void (*testcase) (const line_table_case &));
 192
 193 /* Read the contents of PATH into memory, returning a 0-terminated buffer
 194    that must be freed by the caller.
 195    Fail (and abort) if there are any problems, with LOC as the reported
 196    location of the failure.  */
 197
 198 extern char *read_file (const location &loc, const char *path);
 199
 200 /* Convert a path relative to SRCDIR/gcc/testsuite/selftests
 201    to a real path (either absolute, or relative to pwd).
 202    The result should be freed by the caller.  */
 203
 204 extern char *locate_file (const char *path);
 205
 206 /* The path of SRCDIR/testsuite/selftests.  */
 207
 208 extern const char *path_to_selftest_files;
 209
 210 /* selftest::test_runner is an implementation detail of selftest::run_tests,
 211    exposed here to allow plugins to run their own suites of tests.  */
 212
 213 class test_runner
 214 {
 215  public:
 216   test_runner (const char *name);
 217   ~test_runner ();
 218
 219  private:
 220   const char *m_name;
 221   long m_start_time;
 222 };
 223
 224 /* Declarations for specific families of tests (by source file), in
 225    alphabetical order.  */
 226 extern void attribs_cc_tests ();
 227 extern void bitmap_cc_tests ();
 228 extern void cgraph_cc_tests ();
 229 extern void convert_cc_tests ();
 230 extern void diagnostic_format_json_cc_tests ();
 231 extern void diagnostic_show_locus_cc_tests ();
 232 extern void digraph_cc_tests ();
 233 extern void dumpfile_cc_tests ();
 234 extern void edit_context_cc_tests ();
 235 extern void et_forest_cc_tests ();
 236 extern void fibonacci_heap_cc_tests ();
 237 extern void fold_const_cc_tests ();
 238 extern void function_tests_cc_tests ();
 239 extern void gcc_urlifier_cc_tests ();
 240 extern void ggc_tests_cc_tests ();
 241 extern void gimple_cc_tests ();
 242 extern void hash_map_tests_cc_tests ();
 243 extern void hash_set_tests_cc_tests ();
 244 extern void input_cc_tests ();
 245 extern void json_cc_tests ();
 246 extern void optinfo_emit_json_cc_tests ();
 247 extern void opts_cc_tests ();
 248 extern void ordered_hash_map_tests_cc_tests ();
 249 extern void predict_cc_tests ();
 250 extern void pretty_print_cc_tests ();
 251 extern void range_tests ();
 252 extern void range_op_tests ();
 253 extern void relation_tests ();
 254 extern void gimple_range_tests ();
 255 extern void read_rtl_function_cc_tests ();
 256 extern void rtl_tests_cc_tests ();
 257 extern void sbitmap_cc_tests ();
 258 extern void selftest_cc_tests ();
 259 extern void simplify_rtx_cc_tests ();
 260 extern void spellcheck_cc_tests ();
 261 extern void spellcheck_tree_cc_tests ();
 262 extern void splay_tree_cc_tests ();
 263 extern void sreal_cc_tests ();
 264 extern void store_merging_cc_tests ();
 265 extern void tree_cc_tests ();
 266 extern void tree_cfg_cc_tests ();
 267 extern void tree_diagnostic_path_cc_tests ();
 268 extern void tristate_cc_tests ();
 269 extern void typed_splay_tree_cc_tests ();
 270 extern void vec_cc_tests ();
 271 extern void vec_perm_indices_cc_tests ();
 272 extern void wide_int_cc_tests ();
 273 extern void opt_suggestions_cc_tests ();
 274 extern void dbgcnt_cc_tests ();
 275 extern void ipa_modref_tree_cc_tests ();
 276
 277 extern int num_passes;
 278
 279 } /* end of namespace selftest.  */
 280
 281 /* Macros for writing tests.  */
 282
 283 /* Evaluate EXPR and coerce to bool, calling
 284    ::selftest::pass if it is true,
 285    ::selftest::fail if it false.  */
 286
 287 #define ASSERT_TRUE(EXPR)                               \
 288   ASSERT_TRUE_AT (SELFTEST_LOCATION, (EXPR))
 289
 290 /* Like ASSERT_TRUE, but treat LOC as the effective location of the
 291    selftest.  */
 292
 293 #define ASSERT_TRUE_AT(LOC, EXPR)                       \
 294   SELFTEST_BEGIN_STMT                                   \
 295   const char *desc_ = "ASSERT_TRUE (" #EXPR ")";        \
 296   bool actual_ = (EXPR);                                \
 297   if (actual_)                                          \
 298     ::selftest::pass ((LOC), desc_);                    \
 299   else                                                  \
 300     ::selftest::fail ((LOC), desc_);                    \
 301   SELFTEST_END_STMT
 302
 303 /* Evaluate EXPR and coerce to bool, calling
 304    ::selftest::pass if it is false,
 305    ::selftest::fail if it true.  */
 306
 307 #define ASSERT_FALSE(EXPR)                                      \
 308   ASSERT_FALSE_AT (SELFTEST_LOCATION, (EXPR))
 309
 310 /* Like ASSERT_FALSE, but treat LOC as the effective location of the
 311    selftest.  */
 312
 313 #define ASSERT_FALSE_AT(LOC, EXPR)                              \
 314   SELFTEST_BEGIN_STMT                                           \
 315   const char *desc_ = "ASSERT_FALSE (" #EXPR ")";               \
 316   bool actual_ = (EXPR);                                        \
 317   if (actual_)                                                  \
 318     ::selftest::fail ((LOC), desc_);                            \
 319   else                                                          \
 320     ::selftest::pass ((LOC), desc_);                            \
 321   SELFTEST_END_STMT
 322
 323 /* Evaluate VAL1 and VAL2 and compare them with ==, calling
 324    ::selftest::pass if they are equal,
 325    ::selftest::fail if they are non-equal.  */
 326
 327 #define ASSERT_EQ(VAL1, VAL2) \
 328   ASSERT_EQ_AT ((SELFTEST_LOCATION), (VAL1), (VAL2))
 329
 330 /* Like ASSERT_EQ, but treat LOC as the effective location of the
 331    selftest.  */
 332
 333 #define ASSERT_EQ_AT(LOC, VAL1, VAL2)                  \
 334   SELFTEST_BEGIN_STMT                                          \
 335   const char *desc_ = "ASSERT_EQ (" #VAL1 ", " #VAL2 ")"; \
 336   if ((VAL1) == (VAL2))                                \
 337     ::selftest::pass ((LOC), desc_);                           \
 338   else                                                         \
 339     ::selftest::fail ((LOC), desc_);                           \
 340   SELFTEST_END_STMT
 341
 342 /* Evaluate VAL1 and VAL2 and compare them with known_eq, calling
 343    ::selftest::pass if they are always equal,
 344    ::selftest::fail if they might be non-equal.  */
 345
 346 #define ASSERT_KNOWN_EQ(VAL1, VAL2) \
 347   ASSERT_KNOWN_EQ_AT ((SELFTEST_LOCATION), (VAL1), (VAL2))
 348
 349 /* Like ASSERT_KNOWN_EQ, but treat LOC as the effective location of the
 350    selftest.  */
 351
 352 #define ASSERT_KNOWN_EQ_AT(LOC, VAL1, VAL2)                     \
 353   SELFTEST_BEGIN_STMT                                                   \
 354   const char *desc = "ASSERT_KNOWN_EQ (" #VAL1 ", " #VAL2 ")";  \
 355   if (known_eq (VAL1, VAL2))                                    \
 356     ::selftest::pass ((LOC), desc);                                     \
 357   else                                                                  \
 358     ::selftest::fail ((LOC), desc);                                     \
 359   SELFTEST_END_STMT
 360
 361 /* Evaluate VAL1 and VAL2 and compare them with !=, calling
 362    ::selftest::pass if they are non-equal,
 363    ::selftest::fail if they are equal.  */
 364
 365 #define ASSERT_NE(VAL1, VAL2)                          \
 366   SELFTEST_BEGIN_STMT                                          \
 367   const char *desc_ = "ASSERT_NE (" #VAL1 ", " #VAL2 ")"; \
 368   if ((VAL1) != (VAL2))                                \
 369     ::selftest::pass (SELFTEST_LOCATION, desc_);               \
 370   else                                                         \
 371     ::selftest::fail (SELFTEST_LOCATION, desc_);               \
 372   SELFTEST_END_STMT
 373
 374 /* Like ASSERT_NE, but treat LOC as the effective location of the
 375    selftest.  */
 376
 377 #define ASSERT_NE_AT(LOC, VAL1, VAL2)                  \
 378   SELFTEST_BEGIN_STMT                                          \
 379   const char *desc_ = "ASSERT_NE (" #VAL1 ", " #VAL2 ")"; \
 380   if ((VAL1) != (VAL2))                                \
 381     ::selftest::pass ((LOC), desc_);                           \
 382   else                                                         \
 383     ::selftest::fail ((LOC), desc_);                           \
 384   SELFTEST_END_STMT
 385
 386 /* Evaluate VAL1 and VAL2 and compare them with maybe_ne, calling
 387    ::selftest::pass if they might be non-equal,
 388    ::selftest::fail if they are known to be equal.  */
 389
 390 #define ASSERT_MAYBE_NE(VAL1, VAL2) \
 391   ASSERT_MAYBE_NE_AT ((SELFTEST_LOCATION), (VAL1), (VAL2))
 392
 393 /* Like ASSERT_MAYBE_NE, but treat LOC as the effective location of the
 394    selftest.  */
 395
 396 #define ASSERT_MAYBE_NE_AT(LOC, VAL1, VAL2)                     \
 397   SELFTEST_BEGIN_STMT                                                   \
 398   const char *desc = "ASSERT_MAYBE_NE (" #VAL1 ", " #VAL2 ")";  \
 399   if (maybe_ne (VAL1, VAL2))                                    \
 400     ::selftest::pass ((LOC), desc);                                     \
 401   else                                                                  \
 402     ::selftest::fail ((LOC), desc);                                     \
 403   SELFTEST_END_STMT
 404
 405 /* Evaluate LHS and RHS and compare them with >, calling
 406    ::selftest::pass if LHS > RHS,
 407    ::selftest::fail otherwise.  */
 408
 409 #define ASSERT_GT(LHS, RHS)                             \
 410   ASSERT_GT_AT ((SELFTEST_LOCATION), (LHS), (RHS))
 411
 412 /* Like ASSERT_GT, but treat LOC as the effective location of the
 413    selftest.  */
 414
 415 #define ASSERT_GT_AT(LOC, LHS, RHS)                    \
 416   SELFTEST_BEGIN_STMT                                          \
 417   const char *desc_ = "ASSERT_GT (" #LHS ", " #RHS ")";        \
 418   if ((LHS) > (RHS))                                           \
 419     ::selftest::pass ((LOC), desc_);                           \
 420   else                                                         \
 421     ::selftest::fail ((LOC), desc_);                           \
 422   SELFTEST_END_STMT
 423
 424 /* Evaluate LHS and RHS and compare them with <, calling
 425    ::selftest::pass if LHS < RHS,
 426    ::selftest::fail otherwise.  */
 427
 428 #define ASSERT_LT(LHS, RHS)                             \
 429   ASSERT_LT_AT ((SELFTEST_LOCATION), (LHS), (RHS))
 430
 431 /* Like ASSERT_LT, but treat LOC as the effective location of the
 432    selftest.  */
 433
 434 #define ASSERT_LT_AT(LOC, LHS, RHS)                    \
 435   SELFTEST_BEGIN_STMT                                          \
 436   const char *desc_ = "ASSERT_LT (" #LHS ", " #RHS ")";        \
 437   if ((LHS) < (RHS))                                           \
 438     ::selftest::pass ((LOC), desc_);                           \
 439   else                                                         \
 440     ::selftest::fail ((LOC), desc_);                           \
 441   SELFTEST_END_STMT
 442
 443 /* Evaluate VAL1 and VAL2 and compare them with strcmp, calling
 444    ::selftest::pass if they are equal (and both are non-NULL),
 445    ::selftest::fail if they are non-equal, or are both NULL.  */
 446
 447 #define ASSERT_STREQ(VAL1, VAL2)                                    \
 448   SELFTEST_BEGIN_STMT                                               \
 449   ::selftest::assert_streq (SELFTEST_LOCATION, #VAL1, #VAL2, \
 450                             (VAL1), (VAL2));                \
 451   SELFTEST_END_STMT
 452
 453 /* Like ASSERT_STREQ, but treat LOC as the effective location of the
 454    selftest.  */
 455
 456 #define ASSERT_STREQ_AT(LOC, VAL1, VAL2)                            \
 457   SELFTEST_BEGIN_STMT                                               \
 458   ::selftest::assert_streq ((LOC), #VAL1, #VAL2,                    \
 459                             (VAL1), (VAL2));                \
 460   SELFTEST_END_STMT
 461
 462 /* Evaluate HAYSTACK and NEEDLE and use strstr to determine if NEEDLE
 463    is within HAYSTACK.
 464    ::selftest::pass if NEEDLE is found.
 465    ::selftest::fail if it is not found.  */
 466
 467 #define ASSERT_STR_CONTAINS(HAYSTACK, NEEDLE)                           \
 468   SELFTEST_BEGIN_STMT                                                   \
 469   ::selftest::assert_str_contains (SELFTEST_LOCATION, #HAYSTACK, #NEEDLE, \
 470                                    (HAYSTACK), (NEEDLE));               \
 471   SELFTEST_END_STMT
 472
 473 /* Like ASSERT_STR_CONTAINS, but treat LOC as the effective location of the
 474    selftest.  */
 475
 476 #define ASSERT_STR_CONTAINS_AT(LOC, HAYSTACK, NEEDLE)                   \
 477   SELFTEST_BEGIN_STMT                                                   \
 478   ::selftest::assert_str_contains (LOC, #HAYSTACK, #NEEDLE,             \
 479                                    (HAYSTACK), (NEEDLE));               \
 480   SELFTEST_END_STMT
 481
 482 /* Evaluate STR and PREFIX and determine if STR starts with PREFIX.
 483      ::selftest::pass if STR does start with PREFIX.
 484      ::selftest::fail if does not, or either is NULL.  */
 485
 486 #define ASSERT_STR_STARTSWITH(STR, PREFIX)                                  \
 487   SELFTEST_BEGIN_STMT                                                       \
 488   ::selftest::assert_str_startswith (SELFTEST_LOCATION, #STR, #PREFIX,      \
 489                                      (STR), (PREFIX));                      \
 490   SELFTEST_END_STMT
 491
 492 /* Evaluate PRED1 (VAL1), calling ::selftest::pass if it is true,
 493    ::selftest::fail if it is false.  */
 494
 495 #define ASSERT_PRED1(PRED1, VAL1)                               \
 496   SELFTEST_BEGIN_STMT                                           \
 497   const char *desc_ = "ASSERT_PRED1 (" #PRED1 ", " #VAL1 ")";   \
 498   bool actual_ = (PRED1) (VAL1);                                \
 499   if (actual_)                                                  \
 500     ::selftest::pass (SELFTEST_LOCATION, desc_);                \
 501   else                                                          \
 502     ::selftest::fail (SELFTEST_LOCATION, desc_);                \
 503   SELFTEST_END_STMT
 504
 505 #define SELFTEST_BEGIN_STMT do {
 506 #define SELFTEST_END_STMT   } while (0)
 507
 508 #endif /* #if CHECKING_P */
 509
 510 #endif /* GCC_SELFTEST_H */