Message ID | 20230801022253.3286257-1-lhyatt@gmail.com |
---|---|
State | New |
Headers | show |
Series | preprocessor: c++: Support `#pragma GCC target' macros [PR87299] | expand |
On Mon, 31 Jul 2023, Lewis Hyatt via Gcc-patches wrote: > I added some additional testcases from the PR for x86. The other targets > that support `#pragma GCC target' (aarch64, arm, nios2, powerpc, s390) > already had tests verifying that the pragma sets macros as expected; here I > have added -save-temps to some of them, to test that it now works in > preprocess-only mode as well. It would seem better to have copies of the tests with and without -save-temps, to test in both modes, rather than changing what's tested by an existing test here. Or a test variant that #includes the original test but uses different options, if the original test isn't doing anything that would fail to work with that approach.
On 7/31/23 22:22, Lewis Hyatt via Gcc-patches wrote: > `#pragma GCC target' is not currently handled in preprocess-only mode (e.g., > when running gcc -E or gcc -save-temps). As noted in the PR, this means that > if the target pragma defines any macros, those macros are not effective in > preprocess-only mode. Similarly, such macros are not effective when > compiling with C++ (even when compiling without -save-temps), because C++ > does not process the pragma until after all tokens have been obtained from > libcpp, at which point it is too late for macro expansion to take place. > > Since r13-1544 and r14-2893, there is a general mechanism to handle pragmas > under these conditions as well, so resolve the PR by using the new "early > pragma" support. > > toplev.cc required some changes because the target-specific handlers for > `#pragma GCC target' may call target_reinit(), and toplev.cc was not expecting > that function to be called in preprocess-only mode. > > I added some additional testcases from the PR for x86. The other targets > that support `#pragma GCC target' (aarch64, arm, nios2, powerpc, s390) > already had tests verifying that the pragma sets macros as expected; here I > have added -save-temps to some of them, to test that it now works in > preprocess-only mode as well. > > gcc/c-family/ChangeLog: > > PR preprocessor/87299 > * c-pragma.cc (init_pragma): Register `#pragma GCC target' and > related pragmas in preprocess-only mode, and enable early handling. > (c_reset_target_pragmas): New function refactoring code from... > (handle_pragma_reset_options): ...here. > * c-pragma.h (c_reset_target_pragmas): Declare. > > gcc/cp/ChangeLog: > > PR preprocessor/87299 > * parser.cc (cp_lexer_new_main): Call c_reset_target_pragmas () > after preprocessing is complete, before starting compilation. > > gcc/ChangeLog: > > PR preprocessor/87299 > * toplev.cc (no_backend): New static global. > (finalize): Remove argument no_backend, which is now a > static global. > (process_options): Likewise. > (do_compile): Likewise. > (target_reinit): Don't do anything in preprocess-only mode. > (toplev::main): Adapt to no_backend change. > (toplev::finalize): Likewise. > > gcc/testsuite/ChangeLog: > > PR preprocessor/87299 > * c-c++-common/pragma-target-1.c: New test. > * c-c++-common/pragma-target-2.c: New test. > * g++.target/i386/pr87299-1.C: New test. > * g++.target/i386/pr87299-2.C: New test. > * gcc.target/i386/pr87299-1.c: New test. > * gcc.target/i386/pr87299-2.c: New test. > * gcc.target/s390/target-attribute/tattr-2.c: Add -save-temps to the > options, to test preprocess-only mode as well. > * gcc.target/aarch64/pragma_cpp_predefs_1.c: Likewise. > * gcc.target/arm/pragma_arch_attribute.c: Likewise. > * gcc.target/nios2/custom-fp-2.c: Likewise. > * gcc.target/powerpc/float128-3.c: Likewise. > --- > > Notes: > Hello- > > This patch fixes the PR by enabling early pragma handling for `#pragma GCC > target' and related pragmas such as `#pragma GCC push_options'. I did not > need to touch any target-specific code, however I did need to make a change > to toplev.cc, affecting all targets, to make it safe to call target_reinit() > in preprocess-only mode. (Otherwise, it would be necessary to modify the > implementation of target pragmas in every target, to avoid this code path.) > That was the only complication I ran into. > > Regarding testing, I did: (thanks to GCC compile farm for the non-x86 > targets) > > bootstrap + regtest all languages - x86_64-pc-linux-gnu > bootstrap + regtest c/c++ - powerpc64le-unknown-linux-gnu, > aarch64-unknown-linux-gnu > > The following backends also implement this pragma so ought to be tested: > arm > nios2 > s390 > > I am not able to test those directly. I did add coverage to their testsuites > (basically, adding -save-temps to any existing test, causes it to test the > pragma in preprocess-only mode.) Then, I verified on x86_64 with a cross > compiler, that the modified testcases fail before the patch and pass > afterwards. nios2 is an exception, it does not set any libcpp macros when > handling the pragma, so there is nothing to test, but I did verify that > processing the pragma in preprocess-only mode does not cause any problems. > The cross compilers tested were targets arm-unknown-linux-gnueabi, > nios2-unknown-linux, and s390-ibm-linux. > > Please let me know if it looks OK? Thanks! The c-family and C++ changes look good. David, any comments on the toplev changes? Jason
On Tue, Aug 1, 2023 at 11:01 AM Joseph Myers <joseph@codesourcery.com> wrote: > > On Mon, 31 Jul 2023, Lewis Hyatt via Gcc-patches wrote: > > > I added some additional testcases from the PR for x86. The other targets > > that support `#pragma GCC target' (aarch64, arm, nios2, powerpc, s390) > > already had tests verifying that the pragma sets macros as expected; here I > > have added -save-temps to some of them, to test that it now works in > > preprocess-only mode as well. > > It would seem better to have copies of the tests with and without > -save-temps, to test in both modes, rather than changing what's tested by > an existing test here. Or a test variant that #includes the original test > but uses different options, if the original test isn't doing anything that > would fail to work with that approach. Thank you, I will adjust this. -Lewis
On Tue, Aug 8, 2023 at 5:53 PM Jason Merrill <jason@redhat.com> wrote: > > On 7/31/23 22:22, Lewis Hyatt via Gcc-patches wrote: > > `#pragma GCC target' is not currently handled in preprocess-only mode (e.g., > > when running gcc -E or gcc -save-temps). As noted in the PR, this means that > > if the target pragma defines any macros, those macros are not effective in > > preprocess-only mode. Similarly, such macros are not effective when > > compiling with C++ (even when compiling without -save-temps), because C++ > > does not process the pragma until after all tokens have been obtained from > > libcpp, at which point it is too late for macro expansion to take place. > > > > Since r13-1544 and r14-2893, there is a general mechanism to handle pragmas > > under these conditions as well, so resolve the PR by using the new "early > > pragma" support. > > > > toplev.cc required some changes because the target-specific handlers for > > `#pragma GCC target' may call target_reinit(), and toplev.cc was not expecting > > that function to be called in preprocess-only mode. > > > > I added some additional testcases from the PR for x86. The other targets > > that support `#pragma GCC target' (aarch64, arm, nios2, powerpc, s390) > > already had tests verifying that the pragma sets macros as expected; here I > > have added -save-temps to some of them, to test that it now works in > > preprocess-only mode as well. > > > > gcc/c-family/ChangeLog: > > > > PR preprocessor/87299 > > * c-pragma.cc (init_pragma): Register `#pragma GCC target' and > > related pragmas in preprocess-only mode, and enable early handling. > > (c_reset_target_pragmas): New function refactoring code from... > > (handle_pragma_reset_options): ...here. > > * c-pragma.h (c_reset_target_pragmas): Declare. > > > > gcc/cp/ChangeLog: > > > > PR preprocessor/87299 > > * parser.cc (cp_lexer_new_main): Call c_reset_target_pragmas () > > after preprocessing is complete, before starting compilation. > > > > gcc/ChangeLog: > > > > PR preprocessor/87299 > > * toplev.cc (no_backend): New static global. > > (finalize): Remove argument no_backend, which is now a > > static global. > > (process_options): Likewise. > > (do_compile): Likewise. > > (target_reinit): Don't do anything in preprocess-only mode. > > (toplev::main): Adapt to no_backend change. > > (toplev::finalize): Likewise. > > > > gcc/testsuite/ChangeLog: > > > > PR preprocessor/87299 > > * c-c++-common/pragma-target-1.c: New test. > > * c-c++-common/pragma-target-2.c: New test. > > * g++.target/i386/pr87299-1.C: New test. > > * g++.target/i386/pr87299-2.C: New test. > > * gcc.target/i386/pr87299-1.c: New test. > > * gcc.target/i386/pr87299-2.c: New test. > > * gcc.target/s390/target-attribute/tattr-2.c: Add -save-temps to the > > options, to test preprocess-only mode as well. > > * gcc.target/aarch64/pragma_cpp_predefs_1.c: Likewise. > > * gcc.target/arm/pragma_arch_attribute.c: Likewise. > > * gcc.target/nios2/custom-fp-2.c: Likewise. > > * gcc.target/powerpc/float128-3.c: Likewise. > > --- > > > > Notes: > > Hello- > > > > This patch fixes the PR by enabling early pragma handling for `#pragma GCC > > target' and related pragmas such as `#pragma GCC push_options'. I did not > > need to touch any target-specific code, however I did need to make a change > > to toplev.cc, affecting all targets, to make it safe to call target_reinit() > > in preprocess-only mode. (Otherwise, it would be necessary to modify the > > implementation of target pragmas in every target, to avoid this code path.) > > That was the only complication I ran into. > > > > Regarding testing, I did: (thanks to GCC compile farm for the non-x86 > > targets) > > > > bootstrap + regtest all languages - x86_64-pc-linux-gnu > > bootstrap + regtest c/c++ - powerpc64le-unknown-linux-gnu, > > aarch64-unknown-linux-gnu > > > > The following backends also implement this pragma so ought to be tested: > > arm > > nios2 > > s390 > > > > I am not able to test those directly. I did add coverage to their testsuites > > (basically, adding -save-temps to any existing test, causes it to test the > > pragma in preprocess-only mode.) Then, I verified on x86_64 with a cross > > compiler, that the modified testcases fail before the patch and pass > > afterwards. nios2 is an exception, it does not set any libcpp macros when > > handling the pragma, so there is nothing to test, but I did verify that > > processing the pragma in preprocess-only mode does not cause any problems. > > The cross compilers tested were targets arm-unknown-linux-gnueabi, > > nios2-unknown-linux, and s390-ibm-linux. > > > > Please let me know if it looks OK? Thanks! > > The c-family and C++ changes look good. David, any comments on the > toplev changes? > > Jason > Thanks for the review! To be clear, I should continue to wait for additional feedback on the toplev.cc change, correct? I have also implemented Joseph's suggestion, to add new testcases rather than modifying existing ones. That's a pretty minor change just to the testsuite part so I did not resend the whole patch because of it, but I can if needed. -Lewis
diff --git a/gcc/c-family/c-pragma.cc b/gcc/c-family/c-pragma.cc index 73d59df3bf4..d31d49bfea2 100644 --- a/gcc/c-family/c-pragma.cc +++ b/gcc/c-family/c-pragma.cc @@ -1288,24 +1288,16 @@ handle_pragma_pop_options (cpp_reader *) current_optimize_pragma = p->optimize_strings; } -/* Handle #pragma GCC reset_options to restore the current target and - optimization options to the original options used on the command line. */ +/* This is mostly a helper for handle_pragma_reset_options () to do the actual + work, but the C++ frontend, for example, needs an external interface to + perform this operation, since it processes target pragmas twice. (Once for + preprocessing purposes, and then again during compilation.) */ -static void -handle_pragma_reset_options (cpp_reader *) +void +c_reset_target_pragmas () { - enum cpp_ttype token; - tree x = 0; tree new_optimize = optimization_default_node; tree new_target = target_option_default_node; - - token = pragma_lex (&x); - if (token != CPP_EOF) - { - warning (OPT_Wpragmas, "junk at end of %<#pragma reset_options%>"); - return; - } - if (new_target != target_option_current_node) { (void) targetm.target_option.pragma_parse (NULL_TREE, new_target); @@ -1325,6 +1317,19 @@ handle_pragma_reset_options (cpp_reader *) current_optimize_pragma = NULL_TREE; } +/* Handle #pragma GCC reset_options to restore the current target and + optimization options to the original options used on the command line. */ + +static void +handle_pragma_reset_options (cpp_reader *) +{ + tree x; + if (pragma_lex (&x) != CPP_EOF) + warning (OPT_Wpragmas, "junk at end of %<#pragma reset_options%>"); + else + c_reset_target_pragmas (); +} + /* Print a plain user-specified message. */ static void @@ -1839,11 +1844,19 @@ init_pragma (void) c_register_pragma_with_early_handler ("GCC", "diagnostic", handle_pragma_diagnostic, handle_pragma_diagnostic_early); - c_register_pragma ("GCC", "target", handle_pragma_target); + c_register_pragma_with_early_handler ("GCC", "target", + handle_pragma_target, + handle_pragma_target); c_register_pragma ("GCC", "optimize", handle_pragma_optimize); - c_register_pragma ("GCC", "push_options", handle_pragma_push_options); - c_register_pragma ("GCC", "pop_options", handle_pragma_pop_options); - c_register_pragma ("GCC", "reset_options", handle_pragma_reset_options); + c_register_pragma_with_early_handler ("GCC", "push_options", + handle_pragma_push_options, + handle_pragma_push_options); + c_register_pragma_with_early_handler ("GCC", "pop_options", + handle_pragma_pop_options, + handle_pragma_pop_options); + c_register_pragma_with_early_handler ("GCC", "reset_options", + handle_pragma_reset_options, + handle_pragma_reset_options); c_register_pragma (0, "region", handle_pragma_ignore); c_register_pragma (0, "endregion", handle_pragma_ignore); diff --git a/gcc/c-family/c-pragma.h b/gcc/c-family/c-pragma.h index 198fa7723e5..de5c1c7cced 100644 --- a/gcc/c-family/c-pragma.h +++ b/gcc/c-family/c-pragma.h @@ -255,7 +255,7 @@ c_register_pragma_with_early_handler (const char *space, const char *name, pragma_handler_1arg early_handler); extern void c_invoke_early_pragma_handler (unsigned int); extern void c_pp_invoke_early_pragma_handler (unsigned int); - +extern void c_reset_target_pragmas (); extern void maybe_apply_pragma_weak (tree); extern void maybe_apply_pending_pragma_weaks (void); diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc index 2e245865ea7..ab9262142ea 100644 --- a/gcc/cp/parser.cc +++ b/gcc/cp/parser.cc @@ -761,6 +761,12 @@ cp_lexer_new_main (void) maybe_check_all_macros (parse_in); + /* If we processed any #pragma GCC target directives, we handled them early so + any macros they defined would be effective during preprocessing. Now, we + need to reset to the default state to begin compilation, and we will + process them again at the correct time as needed. */ + c_reset_target_pragmas (); + gcc_assert (!lexer->next_token->purged_p); return lexer; } diff --git a/gcc/testsuite/c-c++-common/pragma-target-1.c b/gcc/testsuite/c-c++-common/pragma-target-1.c new file mode 100644 index 00000000000..2584c228318 --- /dev/null +++ b/gcc/testsuite/c-c++-common/pragma-target-1.c @@ -0,0 +1,19 @@ +/* { dg-do compile { target { i?86-*-* x86_64-*-* } } } */ +/* { dg-options "-mno-avx -O3" } */ + +void f (double *x) +{ + for (int i = 0; i != 8; ++i) + x[i] *= 2; +} + +#pragma GCC target("avx") + +void g (double *x) +{ + for (int i = 0; i != 8; ++i) + x[i] *= 2; +} + +/* Make sure the target pragma affected only g() and not also f(). */ +/* { dg-final { scan-assembler-times vzeroupper 1 } } */ diff --git a/gcc/testsuite/c-c++-common/pragma-target-2.c b/gcc/testsuite/c-c++-common/pragma-target-2.c new file mode 100644 index 00000000000..e7bf305a0eb --- /dev/null +++ b/gcc/testsuite/c-c++-common/pragma-target-2.c @@ -0,0 +1,27 @@ +/* { dg-do preprocess { target { i?86-*-* x86_64-*-* } } } */ +/* { dg-options "-mno-avx" } */ + +#ifdef __AVX__ +#error "__AVX__ should not be defined #1" +#endif + +#pragma GCC target("avx") +#ifndef __AVX__ +#error "__AVX__ should be defined #1" +#endif + +#pragma GCC reset_options +#ifdef __AVX__ +#error "__AVX__ should not be defined #2" +#endif + +#pragma GCC push_options +#pragma GCC target("avx") +#ifndef __AVX__ +#error "__AVX__ should be defined #2" +#endif + +#pragma GCC pop_options +#ifdef __AVX__ +#error "__AVX__ should not be defined #3" +#endif diff --git a/gcc/testsuite/g++.target/i386/pr87299-1.C b/gcc/testsuite/g++.target/i386/pr87299-1.C new file mode 100644 index 00000000000..38d4c3bbc26 --- /dev/null +++ b/gcc/testsuite/g++.target/i386/pr87299-1.C @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-mno-avx" } */ + +#pragma GCC target("avx") +const int x1 = __AVX__; + +_Pragma("GCC target(\"avx512f\")") +const int x2 = __AVX512F__; diff --git a/gcc/testsuite/g++.target/i386/pr87299-2.C b/gcc/testsuite/g++.target/i386/pr87299-2.C new file mode 100644 index 00000000000..263dfb710a0 --- /dev/null +++ b/gcc/testsuite/g++.target/i386/pr87299-2.C @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-save-temps -mno-avx" } */ + +#pragma GCC target("avx") +const int x1 = __AVX__; + +_Pragma("GCC target(\"avx512f\")") +const int x2 = __AVX512F__; diff --git a/gcc/testsuite/gcc.target/aarch64/pragma_cpp_predefs_1.c b/gcc/testsuite/gcc.target/aarch64/pragma_cpp_predefs_1.c index 307fa3d67da..46efa23cedf 100644 --- a/gcc/testsuite/gcc.target/aarch64/pragma_cpp_predefs_1.c +++ b/gcc/testsuite/gcc.target/aarch64/pragma_cpp_predefs_1.c @@ -1,5 +1,5 @@ /* { dg-do compile } */ -/* { dg-options "-O2 -march=armv8-a+crypto" } */ +/* { dg-options "-O2 -march=armv8-a+crypto -save-temps" } */ /* Test that pragma option pushing and popping works. Also that CPP predefines redefinitions on #pragma works. */ diff --git a/gcc/testsuite/gcc.target/arm/pragma_arch_attribute.c b/gcc/testsuite/gcc.target/arm/pragma_arch_attribute.c index a06dbf04037..76ffc4c0d1f 100644 --- a/gcc/testsuite/gcc.target/arm/pragma_arch_attribute.c +++ b/gcc/testsuite/gcc.target/arm/pragma_arch_attribute.c @@ -1,6 +1,7 @@ /* Test for #pragma target macros. */ /* { dg-do compile } */ /* { dg-require-effective-target arm_arch_v8a_ok } */ +/* { dg-additional-options "-save-temps" } */ /* { dg-add-options arm_arch_v8a } */ #include <arm_acle.h> diff --git a/gcc/testsuite/gcc.target/i386/pr87299-1.c b/gcc/testsuite/gcc.target/i386/pr87299-1.c new file mode 100644 index 00000000000..38d4c3bbc26 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr87299-1.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-mno-avx" } */ + +#pragma GCC target("avx") +const int x1 = __AVX__; + +_Pragma("GCC target(\"avx512f\")") +const int x2 = __AVX512F__; diff --git a/gcc/testsuite/gcc.target/i386/pr87299-2.c b/gcc/testsuite/gcc.target/i386/pr87299-2.c new file mode 100644 index 00000000000..263dfb710a0 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr87299-2.c @@ -0,0 +1,8 @@ +/* { dg-do compile } */ +/* { dg-additional-options "-save-temps -mno-avx" } */ + +#pragma GCC target("avx") +const int x1 = __AVX__; + +_Pragma("GCC target(\"avx512f\")") +const int x2 = __AVX512F__; diff --git a/gcc/testsuite/gcc.target/nios2/custom-fp-2.c b/gcc/testsuite/gcc.target/nios2/custom-fp-2.c index fc7c643705e..ce35c63baa8 100644 --- a/gcc/testsuite/gcc.target/nios2/custom-fp-2.c +++ b/gcc/testsuite/gcc.target/nios2/custom-fp-2.c @@ -1,7 +1,7 @@ /* Test specification of custom instructions via pragmas. */ /* { dg-do compile } */ -/* { dg-options "-O1 -ffinite-math-only" } */ +/* { dg-options "-O1 -ffinite-math-only -save-temps" } */ /* -O1 in the options is significant. Without it FP operations may not be optimized to custom instructions. */ diff --git a/gcc/testsuite/gcc.target/powerpc/float128-3.c b/gcc/testsuite/gcc.target/powerpc/float128-3.c index 6daf290d12b..bf8b89d4755 100644 --- a/gcc/testsuite/gcc.target/powerpc/float128-3.c +++ b/gcc/testsuite/gcc.target/powerpc/float128-3.c @@ -1,6 +1,6 @@ /* { dg-do compile { target { powerpc*-*-linux* } } } */ /* { dg-require-effective-target powerpc_vsx_ok } */ -/* { dg-options "-O2 -mvsx -mno-float128" } */ +/* { dg-options "-O2 -mvsx -mno-float128 -save-temps" } */ /* Test that we can use #pragma GCC target to enable -mfloat128. */ diff --git a/gcc/testsuite/gcc.target/s390/target-attribute/tattr-2.c b/gcc/testsuite/gcc.target/s390/target-attribute/tattr-2.c index 739c2eabc83..7ae78fcb9c2 100644 --- a/gcc/testsuite/gcc.target/s390/target-attribute/tattr-2.c +++ b/gcc/testsuite/gcc.target/s390/target-attribute/tattr-2.c @@ -1,8 +1,8 @@ /* Functional tests for the "target" attribute and pragma. */ -/* { dg-do compile */ +/* { dg-do compile } */ /* { dg-require-effective-target target_attribute } */ -/* { dg-options "-O3 -march=zEC12 -mno-htm -fno-ipa-icf" } */ +/* { dg-options "-O3 -march=zEC12 -mno-htm -fno-ipa-icf -save-temps" } */ #pragma GCC target("htm") void p1(void) diff --git a/gcc/toplev.cc b/gcc/toplev.cc index 6c1a6f443c1..685ad9484ac 100644 --- a/gcc/toplev.cc +++ b/gcc/toplev.cc @@ -99,7 +99,7 @@ static void general_init (const char *, bool); static void backend_init (void); static int lang_dependent_init (const char *); static void init_asm_output (const char *); -static void finalize (bool); +static void finalize (); static void crash_signal (int) ATTRIBUTE_NORETURN; static void compile_file (void); @@ -163,6 +163,7 @@ FILE *aux_info_file; FILE *callgraph_info_file = NULL; static bitmap callgraph_info_external_printed; FILE *stack_usage_file = NULL; +static bool no_backend = false; /* The current working directory of a translation. It's generally the directory from which compilation was initiated, but a preprocessed @@ -1221,7 +1222,7 @@ parse_alignment_opts (void) /* Process the options that have been parsed. */ static void -process_options (bool no_backend) +process_options () { const char *language_string = lang_hooks.name; @@ -1871,6 +1872,9 @@ lang_dependent_init (const char *name) void target_reinit (void) { + if (no_backend) + return; + struct rtl_data saved_x_rtl; rtx *saved_regno_reg_rtx; tree saved_optimization_current_node; @@ -1963,7 +1967,7 @@ dump_memory_report (const char *header) /* Clean up: close opened files, etc. */ static void -finalize (bool no_backend) +finalize () { /* Close the dump files. */ if (flag_gen_aux_info) @@ -2045,7 +2049,7 @@ standard_type_bitsize (int bitsize) /* Initialize the compiler, and compile the input file. */ static void -do_compile (bool no_backend) +do_compile () { /* Don't do any more if an error has already occurred. */ if (!seen_error ()) @@ -2132,7 +2136,7 @@ do_compile (bool no_backend) timevar_start (TV_PHASE_FINALIZE); - finalize (no_backend); + finalize (); timevar_stop (TV_PHASE_FINALIZE); } @@ -2273,13 +2277,13 @@ toplev::main (int argc, char **argv) initialization based on the command line options. This hook also sets the original filename if appropriate (e.g. foo.i -> foo.c) so we can correctly initialize debug output. */ - bool no_backend = lang_hooks.post_options (&main_input_filename); + no_backend = lang_hooks.post_options (&main_input_filename); - process_options (no_backend); + process_options (); if (m_use_TV_TOTAL) start_timevars (); - do_compile (no_backend); + do_compile (); if (flag_self_test && !seen_error ()) { @@ -2324,6 +2328,7 @@ toplev::main (int argc, char **argv) void toplev::finalize (void) { + no_backend = false; rtl_initialized = false; this_target_rtl->target_specific_initialized = false;