|
111
|
1 /* A self-testing framework, for use by -fself-test.
|
|
131
|
2 Copyright (C) 2015-2018 Free Software Foundation, Inc.
|
|
111
|
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 namespace selftest {
|
|
|
29
|
|
|
30 /* A struct describing the source-location of a selftest, to make it
|
|
|
31 easier to track down failing tests. */
|
|
|
32
|
|
|
33 struct location
|
|
|
34 {
|
|
|
35 location (const char *file, int line, const char *function)
|
|
|
36 : m_file (file), m_line (line), m_function (function) {}
|
|
|
37
|
|
|
38 const char *m_file;
|
|
|
39 int m_line;
|
|
|
40 const char *m_function;
|
|
|
41 };
|
|
|
42
|
|
|
43 /* A macro for use in selftests and by the ASSERT_ macros below,
|
|
|
44 constructing a selftest::location for the current source location. */
|
|
|
45
|
|
|
46 #define SELFTEST_LOCATION \
|
|
|
47 (::selftest::location (__FILE__, __LINE__, __FUNCTION__))
|
|
|
48
|
|
|
49 /* The entrypoint for running all tests. */
|
|
|
50
|
|
|
51 extern void run_tests ();
|
|
|
52
|
|
|
53 /* Record the successful outcome of some aspect of the test. */
|
|
|
54
|
|
|
55 extern void pass (const location &loc, const char *msg);
|
|
|
56
|
|
|
57 /* Report the failed outcome of some aspect of the test and abort. */
|
|
|
58
|
|
|
59 extern void fail (const location &loc, const char *msg)
|
|
|
60 ATTRIBUTE_NORETURN;
|
|
|
61
|
|
|
62 /* As "fail", but using printf-style formatted output. */
|
|
|
63
|
|
|
64 extern void fail_formatted (const location &loc, const char *fmt, ...)
|
|
|
65 ATTRIBUTE_PRINTF_2 ATTRIBUTE_NORETURN;
|
|
|
66
|
|
|
67 /* Implementation detail of ASSERT_STREQ. */
|
|
|
68
|
|
|
69 extern void assert_streq (const location &loc,
|
|
131
|
70 const char *desc_val1, const char *desc_val2,
|
|
|
71 const char *val1, const char *val2);
|
|
111
|
72
|
|
|
73 /* Implementation detail of ASSERT_STR_CONTAINS. */
|
|
|
74
|
|
|
75 extern void assert_str_contains (const location &loc,
|
|
|
76 const char *desc_haystack,
|
|
|
77 const char *desc_needle,
|
|
|
78 const char *val_haystack,
|
|
|
79 const char *val_needle);
|
|
|
80
|
|
131
|
81 /* Implementation detail of ASSERT_STR_STARTSWITH. */
|
|
|
82
|
|
|
83 extern void assert_str_startswith (const location &loc,
|
|
|
84 const char *desc_str,
|
|
|
85 const char *desc_prefix,
|
|
|
86 const char *val_str,
|
|
|
87 const char *val_prefix);
|
|
|
88
|
|
|
89
|
|
111
|
90 /* A named temporary file for use in selftests.
|
|
|
91 Usable for writing out files, and as the base class for
|
|
|
92 temp_source_file.
|
|
|
93 The file is unlinked in the destructor. */
|
|
|
94
|
|
|
95 class named_temp_file
|
|
|
96 {
|
|
|
97 public:
|
|
|
98 named_temp_file (const char *suffix);
|
|
|
99 ~named_temp_file ();
|
|
|
100 const char *get_filename () const { return m_filename; }
|
|
|
101
|
|
|
102 private:
|
|
|
103 char *m_filename;
|
|
|
104 };
|
|
|
105
|
|
|
106 /* A class for writing out a temporary sourcefile for use in selftests
|
|
|
107 of input handling. */
|
|
|
108
|
|
|
109 class temp_source_file : public named_temp_file
|
|
|
110 {
|
|
|
111 public:
|
|
|
112 temp_source_file (const location &loc, const char *suffix,
|
|
|
113 const char *content);
|
|
|
114 };
|
|
|
115
|
|
131
|
116 /* RAII-style class for avoiding introducing locale-specific differences
|
|
|
117 in strings containing localized quote marks, by temporarily overriding
|
|
|
118 the "open_quote" and "close_quote" globals to something hardcoded.
|
|
|
119
|
|
|
120 Specifically, the C locale's values are used:
|
|
|
121 - open_quote becomes "`"
|
|
|
122 - close_quote becomes "'"
|
|
|
123 for the lifetime of the object. */
|
|
|
124
|
|
|
125 class auto_fix_quotes
|
|
|
126 {
|
|
|
127 public:
|
|
|
128 auto_fix_quotes ();
|
|
|
129 ~auto_fix_quotes ();
|
|
|
130
|
|
|
131 private:
|
|
|
132 const char *m_saved_open_quote;
|
|
|
133 const char *m_saved_close_quote;
|
|
|
134 };
|
|
|
135
|
|
111
|
136 /* Various selftests involving location-handling require constructing a
|
|
|
137 line table and one or more line maps within it.
|
|
|
138
|
|
|
139 For maximum test coverage we want to run these tests with a variety
|
|
|
140 of situations:
|
|
|
141 - line_table->default_range_bits: some frontends use a non-zero value
|
|
|
142 and others use zero
|
|
|
143 - the fallback modes within line-map.c: there are various threshold
|
|
|
144 values for source_location/location_t beyond line-map.c changes
|
|
|
145 behavior (disabling of the range-packing optimization, disabling
|
|
|
146 of column-tracking). We can exercise these by starting the line_table
|
|
|
147 at interesting values at or near these thresholds.
|
|
|
148
|
|
|
149 The following struct describes a particular case within our test
|
|
|
150 matrix. */
|
|
|
151
|
|
|
152 struct line_table_case;
|
|
|
153
|
|
|
154 /* A class for overriding the global "line_table" within a selftest,
|
|
|
155 restoring its value afterwards. At most one instance of this
|
|
|
156 class can exist at once, due to the need to keep the old value
|
|
|
157 of line_table as a GC root. */
|
|
|
158
|
|
|
159 class line_table_test
|
|
|
160 {
|
|
|
161 public:
|
|
|
162 /* Default constructor. Override "line_table", using sane defaults
|
|
|
163 for the temporary line_table. */
|
|
|
164 line_table_test ();
|
|
|
165
|
|
|
166 /* Constructor. Override "line_table", using the case described by C. */
|
|
|
167 line_table_test (const line_table_case &c);
|
|
|
168
|
|
|
169 /* Destructor. Restore the saved line_table. */
|
|
|
170 ~line_table_test ();
|
|
|
171 };
|
|
|
172
|
|
|
173 /* Run TESTCASE multiple times, once for each case in our test matrix. */
|
|
|
174
|
|
|
175 extern void
|
|
|
176 for_each_line_table_case (void (*testcase) (const line_table_case &));
|
|
|
177
|
|
|
178 /* Read the contents of PATH into memory, returning a 0-terminated buffer
|
|
|
179 that must be freed by the caller.
|
|
|
180 Fail (and abort) if there are any problems, with LOC as the reported
|
|
|
181 location of the failure. */
|
|
|
182
|
|
|
183 extern char *read_file (const location &loc, const char *path);
|
|
|
184
|
|
|
185 /* A helper function for writing tests that interact with the
|
|
|
186 garbage collector. */
|
|
|
187
|
|
|
188 extern void forcibly_ggc_collect ();
|
|
|
189
|
|
|
190 /* Convert a path relative to SRCDIR/gcc/testsuite/selftests
|
|
|
191 to a real path (either absolute, or relative to pwd).
|
|
|
192 The result should be freed by the caller. */
|
|
|
193
|
|
|
194 extern char *locate_file (const char *path);
|
|
|
195
|
|
|
196 /* The path of SRCDIR/testsuite/selftests. */
|
|
|
197
|
|
|
198 extern const char *path_to_selftest_files;
|
|
|
199
|
|
131
|
200 /* selftest::test_runner is an implementation detail of selftest::run_tests,
|
|
|
201 exposed here to allow plugins to run their own suites of tests. */
|
|
|
202
|
|
|
203 class test_runner
|
|
|
204 {
|
|
|
205 public:
|
|
|
206 test_runner (const char *name);
|
|
|
207 ~test_runner ();
|
|
|
208
|
|
|
209 private:
|
|
|
210 const char *m_name;
|
|
|
211 long m_start_time;
|
|
|
212 };
|
|
|
213
|
|
111
|
214 /* Declarations for specific families of tests (by source file), in
|
|
|
215 alphabetical order. */
|
|
131
|
216 extern void attribute_c_tests ();
|
|
111
|
217 extern void bitmap_c_tests ();
|
|
|
218 extern void diagnostic_c_tests ();
|
|
|
219 extern void diagnostic_show_locus_c_tests ();
|
|
131
|
220 extern void dumpfile_c_tests ();
|
|
111
|
221 extern void edit_context_c_tests ();
|
|
|
222 extern void et_forest_c_tests ();
|
|
131
|
223 extern void fibonacci_heap_c_tests ();
|
|
111
|
224 extern void fold_const_c_tests ();
|
|
|
225 extern void function_tests_c_tests ();
|
|
131
|
226 extern void ggc_tests_c_tests ();
|
|
111
|
227 extern void gimple_c_tests ();
|
|
|
228 extern void hash_map_tests_c_tests ();
|
|
|
229 extern void hash_set_tests_c_tests ();
|
|
|
230 extern void input_c_tests ();
|
|
131
|
231 extern void json_cc_tests ();
|
|
|
232 extern void opt_problem_cc_tests ();
|
|
|
233 extern void optinfo_emit_json_cc_tests ();
|
|
|
234 extern void predict_c_tests ();
|
|
111
|
235 extern void pretty_print_c_tests ();
|
|
|
236 extern void read_rtl_function_c_tests ();
|
|
|
237 extern void rtl_tests_c_tests ();
|
|
131
|
238 extern void sbitmap_c_tests ();
|
|
111
|
239 extern void selftest_c_tests ();
|
|
131
|
240 extern void simplify_rtx_c_tests ();
|
|
111
|
241 extern void spellcheck_c_tests ();
|
|
|
242 extern void spellcheck_tree_c_tests ();
|
|
|
243 extern void sreal_c_tests ();
|
|
|
244 extern void store_merging_c_tests ();
|
|
|
245 extern void tree_c_tests ();
|
|
|
246 extern void tree_cfg_c_tests ();
|
|
131
|
247 extern void typed_splay_tree_c_tests ();
|
|
111
|
248 extern void unique_ptr_tests_cc_tests ();
|
|
|
249 extern void vec_c_tests ();
|
|
131
|
250 extern void vec_perm_indices_c_tests ();
|
|
111
|
251 extern void wide_int_cc_tests ();
|
|
131
|
252 extern void opt_proposer_c_tests ();
|
|
111
|
253
|
|
|
254 extern int num_passes;
|
|
|
255
|
|
|
256 } /* end of namespace selftest. */
|
|
|
257
|
|
|
258 /* Macros for writing tests. */
|
|
|
259
|
|
|
260 /* Evaluate EXPR and coerce to bool, calling
|
|
|
261 ::selftest::pass if it is true,
|
|
|
262 ::selftest::fail if it false. */
|
|
|
263
|
|
|
264 #define ASSERT_TRUE(EXPR) \
|
|
|
265 ASSERT_TRUE_AT (SELFTEST_LOCATION, (EXPR))
|
|
|
266
|
|
|
267 /* Like ASSERT_TRUE, but treat LOC as the effective location of the
|
|
|
268 selftest. */
|
|
|
269
|
|
|
270 #define ASSERT_TRUE_AT(LOC, EXPR) \
|
|
|
271 SELFTEST_BEGIN_STMT \
|
|
131
|
272 const char *desc_ = "ASSERT_TRUE (" #EXPR ")"; \
|
|
|
273 bool actual_ = (EXPR); \
|
|
|
274 if (actual_) \
|
|
|
275 ::selftest::pass ((LOC), desc_); \
|
|
111
|
276 else \
|
|
131
|
277 ::selftest::fail ((LOC), desc_); \
|
|
111
|
278 SELFTEST_END_STMT
|
|
|
279
|
|
|
280 /* Evaluate EXPR and coerce to bool, calling
|
|
|
281 ::selftest::pass if it is false,
|
|
|
282 ::selftest::fail if it true. */
|
|
|
283
|
|
|
284 #define ASSERT_FALSE(EXPR) \
|
|
|
285 ASSERT_FALSE_AT (SELFTEST_LOCATION, (EXPR))
|
|
|
286
|
|
|
287 /* Like ASSERT_FALSE, but treat LOC as the effective location of the
|
|
|
288 selftest. */
|
|
|
289
|
|
|
290 #define ASSERT_FALSE_AT(LOC, EXPR) \
|
|
|
291 SELFTEST_BEGIN_STMT \
|
|
131
|
292 const char *desc_ = "ASSERT_FALSE (" #EXPR ")"; \
|
|
|
293 bool actual_ = (EXPR); \
|
|
|
294 if (actual_) \
|
|
|
295 ::selftest::fail ((LOC), desc_); \
|
|
|
296 else \
|
|
|
297 ::selftest::pass ((LOC), desc_); \
|
|
111
|
298 SELFTEST_END_STMT
|
|
|
299
|
|
131
|
300 /* Evaluate VAL1 and VAL2 and compare them with ==, calling
|
|
111
|
301 ::selftest::pass if they are equal,
|
|
|
302 ::selftest::fail if they are non-equal. */
|
|
|
303
|
|
131
|
304 #define ASSERT_EQ(VAL1, VAL2) \
|
|
|
305 ASSERT_EQ_AT ((SELFTEST_LOCATION), (VAL1), (VAL2))
|
|
111
|
306
|
|
|
307 /* Like ASSERT_EQ, but treat LOC as the effective location of the
|
|
|
308 selftest. */
|
|
|
309
|
|
131
|
310 #define ASSERT_EQ_AT(LOC, VAL1, VAL2) \
|
|
111
|
311 SELFTEST_BEGIN_STMT \
|
|
131
|
312 const char *desc_ = "ASSERT_EQ (" #VAL1 ", " #VAL2 ")"; \
|
|
|
313 if ((VAL1) == (VAL2)) \
|
|
|
314 ::selftest::pass ((LOC), desc_); \
|
|
111
|
315 else \
|
|
131
|
316 ::selftest::fail ((LOC), desc_); \
|
|
111
|
317 SELFTEST_END_STMT
|
|
|
318
|
|
131
|
319 /* Evaluate VAL1 and VAL2 and compare them with known_eq, calling
|
|
|
320 ::selftest::pass if they are always equal,
|
|
|
321 ::selftest::fail if they might be non-equal. */
|
|
|
322
|
|
|
323 #define ASSERT_KNOWN_EQ(VAL1, VAL2) \
|
|
|
324 ASSERT_KNOWN_EQ_AT ((SELFTEST_LOCATION), (VAL1), (VAL2))
|
|
|
325
|
|
|
326 /* Like ASSERT_KNOWN_EQ, but treat LOC as the effective location of the
|
|
|
327 selftest. */
|
|
|
328
|
|
|
329 #define ASSERT_KNOWN_EQ_AT(LOC, VAL1, VAL2) \
|
|
|
330 SELFTEST_BEGIN_STMT \
|
|
|
331 const char *desc = "ASSERT_KNOWN_EQ (" #VAL1 ", " #VAL2 ")"; \
|
|
|
332 if (known_eq (VAL1, VAL2)) \
|
|
|
333 ::selftest::pass ((LOC), desc); \
|
|
|
334 else \
|
|
|
335 ::selftest::fail ((LOC), desc); \
|
|
|
336 SELFTEST_END_STMT
|
|
|
337
|
|
|
338 /* Evaluate VAL1 and VAL2 and compare them with !=, calling
|
|
111
|
339 ::selftest::pass if they are non-equal,
|
|
|
340 ::selftest::fail if they are equal. */
|
|
|
341
|
|
131
|
342 #define ASSERT_NE(VAL1, VAL2) \
|
|
111
|
343 SELFTEST_BEGIN_STMT \
|
|
131
|
344 const char *desc_ = "ASSERT_NE (" #VAL1 ", " #VAL2 ")"; \
|
|
|
345 if ((VAL1) != (VAL2)) \
|
|
|
346 ::selftest::pass (SELFTEST_LOCATION, desc_); \
|
|
111
|
347 else \
|
|
131
|
348 ::selftest::fail (SELFTEST_LOCATION, desc_); \
|
|
|
349 SELFTEST_END_STMT
|
|
|
350
|
|
|
351 /* Evaluate VAL1 and VAL2 and compare them with maybe_ne, calling
|
|
|
352 ::selftest::pass if they might be non-equal,
|
|
|
353 ::selftest::fail if they are known to be equal. */
|
|
|
354
|
|
|
355 #define ASSERT_MAYBE_NE(VAL1, VAL2) \
|
|
|
356 ASSERT_MAYBE_NE_AT ((SELFTEST_LOCATION), (VAL1), (VAL2))
|
|
|
357
|
|
|
358 /* Like ASSERT_MAYBE_NE, but treat LOC as the effective location of the
|
|
|
359 selftest. */
|
|
|
360
|
|
|
361 #define ASSERT_MAYBE_NE_AT(LOC, VAL1, VAL2) \
|
|
|
362 SELFTEST_BEGIN_STMT \
|
|
|
363 const char *desc = "ASSERT_MAYBE_NE (" #VAL1 ", " #VAL2 ")"; \
|
|
|
364 if (maybe_ne (VAL1, VAL2)) \
|
|
|
365 ::selftest::pass ((LOC), desc); \
|
|
|
366 else \
|
|
|
367 ::selftest::fail ((LOC), desc); \
|
|
111
|
368 SELFTEST_END_STMT
|
|
|
369
|
|
131
|
370 /* Evaluate LHS and RHS and compare them with >, calling
|
|
|
371 ::selftest::pass if LHS > RHS,
|
|
|
372 ::selftest::fail otherwise. */
|
|
|
373
|
|
|
374 #define ASSERT_GT(LHS, RHS) \
|
|
|
375 ASSERT_GT_AT ((SELFTEST_LOCATION), (LHS), (RHS))
|
|
|
376
|
|
|
377 /* Like ASSERT_GT, but treat LOC as the effective location of the
|
|
|
378 selftest. */
|
|
|
379
|
|
|
380 #define ASSERT_GT_AT(LOC, LHS, RHS) \
|
|
|
381 SELFTEST_BEGIN_STMT \
|
|
|
382 const char *desc_ = "ASSERT_GT (" #LHS ", " #RHS ")"; \
|
|
|
383 if ((LHS) > (RHS)) \
|
|
|
384 ::selftest::pass ((LOC), desc_); \
|
|
|
385 else \
|
|
|
386 ::selftest::fail ((LOC), desc_); \
|
|
|
387 SELFTEST_END_STMT
|
|
|
388
|
|
|
389 /* Evaluate LHS and RHS and compare them with <, calling
|
|
|
390 ::selftest::pass if LHS < RHS,
|
|
|
391 ::selftest::fail otherwise. */
|
|
111
|
392
|
|
131
|
393 #define ASSERT_LT(LHS, RHS) \
|
|
|
394 ASSERT_LT_AT ((SELFTEST_LOCATION), (LHS), (RHS))
|
|
|
395
|
|
|
396 /* Like ASSERT_LT, but treat LOC as the effective location of the
|
|
|
397 selftest. */
|
|
|
398
|
|
|
399 #define ASSERT_LT_AT(LOC, LHS, RHS) \
|
|
|
400 SELFTEST_BEGIN_STMT \
|
|
|
401 const char *desc_ = "ASSERT_LT (" #LHS ", " #RHS ")"; \
|
|
|
402 if ((LHS) < (RHS)) \
|
|
|
403 ::selftest::pass ((LOC), desc_); \
|
|
|
404 else \
|
|
|
405 ::selftest::fail ((LOC), desc_); \
|
|
|
406 SELFTEST_END_STMT
|
|
|
407
|
|
|
408 /* Evaluate VAL1 and VAL2 and compare them with strcmp, calling
|
|
|
409 ::selftest::pass if they are equal (and both are non-NULL),
|
|
|
410 ::selftest::fail if they are non-equal, or are both NULL. */
|
|
|
411
|
|
|
412 #define ASSERT_STREQ(VAL1, VAL2) \
|
|
111
|
413 SELFTEST_BEGIN_STMT \
|
|
131
|
414 ::selftest::assert_streq (SELFTEST_LOCATION, #VAL1, #VAL2, \
|
|
|
415 (VAL1), (VAL2)); \
|
|
111
|
416 SELFTEST_END_STMT
|
|
|
417
|
|
|
418 /* Like ASSERT_STREQ, but treat LOC as the effective location of the
|
|
|
419 selftest. */
|
|
|
420
|
|
131
|
421 #define ASSERT_STREQ_AT(LOC, VAL1, VAL2) \
|
|
111
|
422 SELFTEST_BEGIN_STMT \
|
|
131
|
423 ::selftest::assert_streq ((LOC), #VAL1, #VAL2, \
|
|
|
424 (VAL1), (VAL2)); \
|
|
111
|
425 SELFTEST_END_STMT
|
|
|
426
|
|
|
427 /* Evaluate HAYSTACK and NEEDLE and use strstr to determine if NEEDLE
|
|
|
428 is within HAYSTACK.
|
|
|
429 ::selftest::pass if NEEDLE is found.
|
|
|
430 ::selftest::fail if it is not found. */
|
|
|
431
|
|
|
432 #define ASSERT_STR_CONTAINS(HAYSTACK, NEEDLE) \
|
|
|
433 SELFTEST_BEGIN_STMT \
|
|
|
434 ::selftest::assert_str_contains (SELFTEST_LOCATION, #HAYSTACK, #NEEDLE, \
|
|
|
435 (HAYSTACK), (NEEDLE)); \
|
|
|
436 SELFTEST_END_STMT
|
|
|
437
|
|
131
|
438 /* Evaluate STR and PREFIX and determine if STR starts with PREFIX.
|
|
|
439 ::selftest::pass if STR does start with PREFIX.
|
|
|
440 ::selftest::fail if does not, or either is NULL. */
|
|
|
441
|
|
|
442 #define ASSERT_STR_STARTSWITH(STR, PREFIX) \
|
|
|
443 SELFTEST_BEGIN_STMT \
|
|
|
444 ::selftest::assert_str_startswith (SELFTEST_LOCATION, #STR, #PREFIX, \
|
|
|
445 (STR), (PREFIX)); \
|
|
|
446 SELFTEST_END_STMT
|
|
|
447
|
|
111
|
448 /* Evaluate PRED1 (VAL1), calling ::selftest::pass if it is true,
|
|
|
449 ::selftest::fail if it is false. */
|
|
|
450
|
|
131
|
451 #define ASSERT_PRED1(PRED1, VAL1) \
|
|
|
452 SELFTEST_BEGIN_STMT \
|
|
|
453 const char *desc_ = "ASSERT_PRED1 (" #PRED1 ", " #VAL1 ")"; \
|
|
|
454 bool actual_ = (PRED1) (VAL1); \
|
|
|
455 if (actual_) \
|
|
|
456 ::selftest::pass (SELFTEST_LOCATION, desc_); \
|
|
|
457 else \
|
|
|
458 ::selftest::fail (SELFTEST_LOCATION, desc_); \
|
|
111
|
459 SELFTEST_END_STMT
|
|
|
460
|
|
|
461 #define SELFTEST_BEGIN_STMT do {
|
|
|
462 #define SELFTEST_END_STMT } while (0)
|
|
|
463
|
|
|
464 #endif /* #if CHECKING_P */
|
|
|
465
|
|
|
466 #endif /* GCC_SELFTEST_H */
|
