https://gcc.gnu.org/g:86ab82906baff66d2372b797a7980aea35078584
commit r17-1218-g86ab82906baff66d2372b797a7980aea35078584 Author: Christopher Bazley <[email protected]> Date: Wed Apr 29 12:33:05 2026 +0000 c-family: Prevent optimize attribute from undoing target attribute This patch fixes a bug reported as PR c/125327. Previously, function attributes such as __attribute__ ((target ("vsx"), optimize("O2"))) could be applied wrongly because correct processing of the optimize attribute relied on at least one of the following to be true: 1. The function had no function-specific target options, or 2. changing optimization options did not have the side-effect of modifying target options, or 3. the target option modified as a side-effect of changing optimization options was not saved in the cl_target_option struct. Assumptions 2 and 3 are not generally guaranteed to be true. The implementation of the handle_optimize_attribute function already implicitly acknowledged that by rebuilding the target options after parsing optimization options, and replacing the current target option node if that rebuilding resulted in a fresh target option node. However, any target options already associated with the function being modified were not applied before parsing optimization options, therefore they were lost if that function's target option node was replaced. Moreover, the decision about whether to replace any existing target option node was flawed because it was based on a comparison with a fake node built from ambient global state instead of a comparison with the current target node. Assumption 3 is true for i386 because the i386 definition of munroll-only-small-loops does not have the "Save" tag, therefore its value cannot differ from the ambient global state and the target node of the function was not replaced. The rs6000 and s390 definitions of munroll-only-small-loops (which is likewise implicitly enabled at -O2 and above) *do* have the "Save" tag but the 'target' attribute is not supported on s390, therefore the bug can only be reproduced on rs6000. For the bug to manifest, the target option node needed to be replaced. For rs6000, that could happen if the newly-saved value of munroll-only-small-loops differed from the ambient global state (which was wrongly used as the baseline for the comparison) even if the newly-saved value did not differ from the value previously saved in the target option node of the function whose 'optimize' attribute was being applied. gcc/c-family/ChangeLog: * c-attribs.cc (handle_optimize_attribute): Save the global target options before modifying them. If the function with the optimize attribute already has a target option node then restore those target options as the global options, so that they are used as the basis for any new optimization and target options attached to the function. gcc/d/ChangeLog: * d-attribs.cc (d_handle_optimize_attribute): Save the global target options before modifying them. If the function with the optimize attribute already has a target option node then restore those target options as the global options, so that they are used as the basis for any new optimization and target options attached to the function. gcc/testsuite/ChangeLog: * gcc.target/powerpc/pr125327.c: New test. Diff: --- gcc/c-family/c-attribs.cc | 16 +++++++++++++--- gcc/d/d-attribs.cc | 16 +++++++++++++--- gcc/testsuite/gcc.target/powerpc/pr125327.c | 24 ++++++++++++++++++++++++ 3 files changed, 50 insertions(+), 6 deletions(-) diff --git a/gcc/c-family/c-attribs.cc b/gcc/c-family/c-attribs.cc index 60b57f44362d..88293c37e4ee 100644 --- a/gcc/c-family/c-attribs.cc +++ b/gcc/c-family/c-attribs.cc @@ -6468,12 +6468,18 @@ handle_optimize_attribute (tree *node, tree name, tree args, else { struct cl_optimization cur_opts; + struct cl_target_option cur_target; tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node); + tree old_target = DECL_FUNCTION_SPECIFIC_TARGET (*node); /* Save current options. */ cl_optimization_save (&cur_opts, &global_options, &global_options_set); - tree prev_target_node = build_target_option_node (&global_options, - &global_options_set); + cl_target_option_save (&cur_target, &global_options, &global_options_set); + + tree prev_target_node + = old_target + ? old_target + : build_target_option_node (&global_options, &global_options_set); /* If we previously had some optimization options, use them as the default. */ @@ -6492,6 +6498,10 @@ handle_optimize_attribute (tree *node, tree name, tree args, cl_optimization_restore (&global_options, &global_options_set, TREE_OPTIMIZATION (old_opts)); + if (old_target) + cl_target_option_restore (&global_options, &global_options_set, + TREE_TARGET_OPTION (old_target)); + /* Parse options, and update the vector. */ parse_optimize_options (args, true); DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) @@ -6509,7 +6519,7 @@ handle_optimize_attribute (tree *node, tree name, tree args, cl_optimization_restore (&global_options, &global_options_set, &cur_opts); cl_target_option_restore (&global_options, &global_options_set, - TREE_TARGET_OPTION (prev_target_node)); + &cur_target); if (saved_global_options != NULL) { diff --git a/gcc/d/d-attribs.cc b/gcc/d/d-attribs.cc index 6b3ec82e30a3..803f2e05bbd2 100644 --- a/gcc/d/d-attribs.cc +++ b/gcc/d/d-attribs.cc @@ -923,12 +923,18 @@ d_handle_optimize_attribute (tree *node, tree name, tree args, int, else { struct cl_optimization cur_opts; + struct cl_target_option cur_target; tree old_opts = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node); + tree old_target = DECL_FUNCTION_SPECIFIC_TARGET (*node); /* Save current options. */ cl_optimization_save (&cur_opts, &global_options, &global_options_set); - tree prev_target_node = build_target_option_node (&global_options, - &global_options_set); + cl_target_option_save (&cur_target, &global_options, &global_options_set); + + tree prev_target_node + = old_target + ? old_target + : build_target_option_node (&global_options, &global_options_set); /* If we previously had some optimization options, use them as the default. */ @@ -943,6 +949,10 @@ d_handle_optimize_attribute (tree *node, tree name, tree args, int, cl_optimization_restore (&global_options, &global_options_set, TREE_OPTIMIZATION (old_opts)); + if (old_target) + cl_target_option_restore (&global_options, &global_options_set, + TREE_TARGET_OPTION (old_target)); + /* Parse options, and update the vector. */ parse_optimize_options (args); DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) @@ -956,7 +966,7 @@ d_handle_optimize_attribute (tree *node, tree name, tree args, int, cl_optimization_restore (&global_options, &global_options_set, &cur_opts); cl_target_option_restore (&global_options, &global_options_set, - TREE_TARGET_OPTION (prev_target_node)); + &cur_target); if (saved_global_options != NULL) { cl_optimization_compare (saved_global_options, &global_options); diff --git a/gcc/testsuite/gcc.target/powerpc/pr125327.c b/gcc/testsuite/gcc.target/powerpc/pr125327.c new file mode 100644 index 000000000000..b7bde8532e09 --- /dev/null +++ b/gcc/testsuite/gcc.target/powerpc/pr125327.c @@ -0,0 +1,24 @@ +/* { dg-do compile } */ +/* { dg-options "-O1 -mcpu=power8 -mno-vsx" } */ + +typedef double v2df __attribute__ ((vector_size (16))); + +/* This is a test for preservation of target-specific options when optimization + options are changed. If the optimize() attribute is not applied correctly, + then the values of any target-specific options already set by the target() + attribute can be lost. The vector/scalar (VSX) instruction enablement flag + associated with foo() should be preserved when the optimization level is + changed from 1 to 2, because neither -mvsx nor -mno-vsx is implied by -O2; + however, an unrelated target-specific option, -munroll-only-small-loops, *is* + implied by -O2, which requires the function's target option node to be + rebuilt. When that happens, the existing value of the VSX flag must be + preserved. + */ + +v2df __attribute__ ((target ("vsx"), optimize("O2"))) +foo (double a, double b) +{ + return (v2df){a, b}; +} + +/* { dg-final { scan-assembler {\txxpermdi } } } */
