commit: 462456df6da32e138cdc1e18df6e681cc2dc948a Author: Sam James <sam <AT> gentoo <DOT> org> AuthorDate: Fri Oct 18 10:34:47 2024 +0000 Commit: Sam James <sam <AT> gentoo <DOT> org> CommitDate: Fri Oct 18 10:34:47 2024 +0000 URL: https://gitweb.gentoo.org/proj/gcc-patches.git/commit/?id=462456df
15.0.0: revert some embed patches Do as Jakub suggests at https://gcc.gnu.org/bugzilla/show_bug.cgi?id=117190#c3 and revert these for now until a fix can be applied. Bug: https://gcc.gnu.org/PR117190 Bug: https://gcc.gnu.org/PR117199 Bug: https://gcc.gnu.org/PR117201 Signed-off-by: Sam James <sam <AT> gentoo.org> ...x-up-speed-up-compilation-of-large-char-a.patch | 97 ++++++++++ ...eed-up-compilation-of-large-char-array-in.patch | 212 +++++++++++++++++++++ 2 files changed, 309 insertions(+) diff --git a/15.0.0/gentoo/73_all_PR117190-Revert-c-Fix-up-speed-up-compilation-of-large-char-a.patch b/15.0.0/gentoo/73_all_PR117190-Revert-c-Fix-up-speed-up-compilation-of-large-char-a.patch new file mode 100644 index 0000000..47f26cc --- /dev/null +++ b/15.0.0/gentoo/73_all_PR117190-Revert-c-Fix-up-speed-up-compilation-of-large-char-a.patch @@ -0,0 +1,97 @@ +From bfec21e6cf88b0b64bfcc30d2f5ae3b3370e36e3 Mon Sep 17 00:00:00 2001 +Message-ID: <bfec21e6cf88b0b64bfcc30d2f5ae3b3370e36e3.1729247640.git....@gentoo.org> +From: Sam James <[email protected]> +Date: Fri, 18 Oct 2024 11:31:20 +0100 +Subject: [PATCH 1/2] Revert "c: Fix up speed up compilation of large char + array initializers when not using #embed [PR117177]" + +This reverts commit 96ba5e5663d4390a7e69735ce3c9de657fc543fc. + +Keep the testcase. + +Bug: https://gcc.gnu.org/PR117190 +--- + gcc/c/c-parser.cc | 35 ++++++++++------------------------- + 1 file changed, 10 insertions(+), 25 deletions(-) + +diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc +index 090ab1cbc088..e4381044e5cb 100644 +--- a/gcc/c/c-parser.cc ++++ b/gcc/c/c-parser.cc +@@ -6529,7 +6529,6 @@ c_parser_initval (c_parser *parser, struct c_expr *after, + unsigned int i; + gcc_checking_assert (len >= 64); + location_t last_loc = UNKNOWN_LOCATION; +- location_t prev_loc = UNKNOWN_LOCATION; + for (i = 0; i < 64; ++i) + { + c_token *tok = c_parser_peek_nth_token_raw (parser, 1 + 2 * i); +@@ -6545,7 +6544,6 @@ c_parser_initval (c_parser *parser, struct c_expr *after, + buf1[i] = (char) tree_to_uhwi (tok->value); + if (i == 0) + loc = tok->location; +- prev_loc = last_loc; + last_loc = tok->location; + } + if (i < 64) +@@ -6569,7 +6567,6 @@ c_parser_initval (c_parser *parser, struct c_expr *after, + unsigned int max_len = 131072 - offsetof (struct tree_string, str) - 1; + unsigned int orig_len = len; + unsigned int off = 0, last = 0; +- unsigned char lastc = 0; + if (!wi::neg_p (wi::to_wide (val)) && wi::to_widest (val) <= UCHAR_MAX) + off = 1; + len = MIN (len, max_len - off); +@@ -6599,25 +6596,20 @@ c_parser_initval (c_parser *parser, struct c_expr *after, + if (tok2->type != CPP_COMMA && tok2->type != CPP_CLOSE_BRACE) + break; + buf2[i + off] = (char) tree_to_uhwi (tok->value); +- prev_loc = last_loc; ++ /* If orig_len is INT_MAX, this can be flexible array member and ++ in that case we need to ensure another element which ++ for CPP_EMBED is normally guaranteed after it. Include ++ that byte in the RAW_DATA_OWNER though, so it can be optimized ++ later. */ ++ if (tok2->type == CPP_CLOSE_BRACE && orig_len == INT_MAX) ++ { ++ last = 1; ++ break; ++ } + last_loc = tok->location; + c_parser_consume_token (parser); + c_parser_consume_token (parser); + } +- /* If orig_len is INT_MAX, this can be flexible array member and +- in that case we need to ensure another element which +- for CPP_EMBED is normally guaranteed after it. Include +- that byte in the RAW_DATA_OWNER though, so it can be optimized +- later. */ +- if (orig_len == INT_MAX +- && (!c_parser_next_token_is (parser, CPP_COMMA) +- || c_parser_peek_2nd_token (parser)->type != CPP_NUMBER)) +- { +- --i; +- last = 1; +- std::swap (prev_loc, last_loc); +- lastc = (unsigned char) buf2[i + off]; +- } + val = make_node (RAW_DATA_CST); + TREE_TYPE (val) = integer_type_node; + RAW_DATA_LENGTH (val) = i; +@@ -6633,13 +6625,6 @@ c_parser_initval (c_parser *parser, struct c_expr *after, + init.original_type = integer_type_node; + init.m_decimal = 0; + process_init_element (loc, init, false, braced_init_obstack); +- if (last) +- { +- init.value = build_int_cst (integer_type_node, lastc); +- init.original_code = INTEGER_CST; +- set_c_expr_source_range (&init, prev_loc, prev_loc); +- process_init_element (prev_loc, init, false, braced_init_obstack); +- } + } + } + +-- +2.47.0 + diff --git a/15.0.0/gentoo/74_all_PR117190-Revert-c-Speed-up-compilation-of-large-char-array-in.patch b/15.0.0/gentoo/74_all_PR117190-Revert-c-Speed-up-compilation-of-large-char-array-in.patch new file mode 100644 index 0000000..889c961 --- /dev/null +++ b/15.0.0/gentoo/74_all_PR117190-Revert-c-Speed-up-compilation-of-large-char-array-in.patch @@ -0,0 +1,212 @@ +From ec2844301e40a017a32b4f11f499d6db7629c6bf Mon Sep 17 00:00:00 2001 +Message-ID: <ec2844301e40a017a32b4f11f499d6db7629c6bf.1729247640.git....@gentoo.org> +In-Reply-To: <bfec21e6cf88b0b64bfcc30d2f5ae3b3370e36e3.1729247640.git....@gentoo.org> +References: <bfec21e6cf88b0b64bfcc30d2f5ae3b3370e36e3.1729247640.git....@gentoo.org> +From: Sam James <[email protected]> +Date: Fri, 18 Oct 2024 11:31:27 +0100 +Subject: [PATCH 2/2] Revert "c: Speed up compilation of large char array + initializers when not using #embed" + +This reverts commit f9bac238840155e1539aa68daf1507ea63c9ed80. + +Keep the testcase. + +Bug: https://gcc.gnu.org/PR117190 +--- + gcc/c/c-parser.cc | 118 ---------------------------------------------- + gcc/c/c-tree.h | 1 - + gcc/c/c-typeck.cc | 36 -------------- + 3 files changed, 155 deletions(-) + +diff --git a/gcc/c/c-parser.cc b/gcc/c/c-parser.cc +index e4381044e5cb..9518459a0a57 100644 +--- a/gcc/c/c-parser.cc ++++ b/gcc/c/c-parser.cc +@@ -6507,125 +6507,7 @@ c_parser_initval (c_parser *parser, struct c_expr *after, + (init.value)))) + init = convert_lvalue_to_rvalue (loc, init, true, true, true); + } +- tree val = init.value; + process_init_element (loc, init, false, braced_init_obstack); +- +- /* Attempt to optimize large char array initializers into RAW_DATA_CST +- to save compile time and memory even when not using #embed. */ +- static unsigned vals_to_ignore; +- if (vals_to_ignore) +- /* If earlier call determined there is certain number of CPP_COMMA +- CPP_NUMBER tokens with 0-255 int values, but not enough for +- RAW_DATA_CST to be beneficial, don't try to check it again until +- they are all parsed. */ +- --vals_to_ignore; +- else if (val +- && TREE_CODE (val) == INTEGER_CST +- && TREE_TYPE (val) == integer_type_node +- && c_parser_next_token_is (parser, CPP_COMMA)) +- if (unsigned int len = c_maybe_optimize_large_byte_initializer ()) +- { +- char buf1[64]; +- unsigned int i; +- gcc_checking_assert (len >= 64); +- location_t last_loc = UNKNOWN_LOCATION; +- for (i = 0; i < 64; ++i) +- { +- c_token *tok = c_parser_peek_nth_token_raw (parser, 1 + 2 * i); +- if (tok->type != CPP_COMMA) +- break; +- tok = c_parser_peek_nth_token_raw (parser, 2 + 2 * i); +- if (tok->type != CPP_NUMBER +- || TREE_CODE (tok->value) != INTEGER_CST +- || TREE_TYPE (tok->value) != integer_type_node +- || wi::neg_p (wi::to_wide (tok->value)) +- || wi::to_widest (tok->value) > UCHAR_MAX) +- break; +- buf1[i] = (char) tree_to_uhwi (tok->value); +- if (i == 0) +- loc = tok->location; +- last_loc = tok->location; +- } +- if (i < 64) +- { +- vals_to_ignore = i; +- return; +- } +- c_token *tok = c_parser_peek_nth_token_raw (parser, 1 + 2 * i); +- /* If 64 CPP_COMMA CPP_NUMBER pairs are followed by CPP_CLOSE_BRACE, +- punt if len is INT_MAX as that can mean this is a flexible array +- member and in that case we need one CPP_NUMBER afterwards +- (as guaranteed for CPP_EMBED). */ +- if (tok->type == CPP_CLOSE_BRACE && len != INT_MAX) +- len = i; +- else if (tok->type != CPP_COMMA) +- { +- vals_to_ignore = i; +- return; +- } +- /* Ensure the STRING_CST fits into 128K. */ +- unsigned int max_len = 131072 - offsetof (struct tree_string, str) - 1; +- unsigned int orig_len = len; +- unsigned int off = 0, last = 0; +- if (!wi::neg_p (wi::to_wide (val)) && wi::to_widest (val) <= UCHAR_MAX) +- off = 1; +- len = MIN (len, max_len - off); +- char *buf2 = XNEWVEC (char, len + off); +- if (off) +- buf2[0] = (char) tree_to_uhwi (val); +- memcpy (buf2 + off, buf1, i); +- for (unsigned int j = 0; j < i; ++j) +- { +- c_parser_peek_token (parser); +- c_parser_consume_token (parser); +- c_parser_peek_token (parser); +- c_parser_consume_token (parser); +- } +- for (; i < len; ++i) +- { +- if (!c_parser_next_token_is (parser, CPP_COMMA)) +- break; +- tok = c_parser_peek_2nd_token (parser); +- if (tok->type != CPP_NUMBER +- || TREE_CODE (tok->value) != INTEGER_CST +- || TREE_TYPE (tok->value) != integer_type_node +- || wi::neg_p (wi::to_wide (tok->value)) +- || wi::to_widest (tok->value) > UCHAR_MAX) +- break; +- c_token *tok2 = c_parser_peek_nth_token (parser, 3); +- if (tok2->type != CPP_COMMA && tok2->type != CPP_CLOSE_BRACE) +- break; +- buf2[i + off] = (char) tree_to_uhwi (tok->value); +- /* If orig_len is INT_MAX, this can be flexible array member and +- in that case we need to ensure another element which +- for CPP_EMBED is normally guaranteed after it. Include +- that byte in the RAW_DATA_OWNER though, so it can be optimized +- later. */ +- if (tok2->type == CPP_CLOSE_BRACE && orig_len == INT_MAX) +- { +- last = 1; +- break; +- } +- last_loc = tok->location; +- c_parser_consume_token (parser); +- c_parser_consume_token (parser); +- } +- val = make_node (RAW_DATA_CST); +- TREE_TYPE (val) = integer_type_node; +- RAW_DATA_LENGTH (val) = i; +- tree owner = build_string (i + off + last, buf2); +- XDELETEVEC (buf2); +- TREE_TYPE (owner) = build_array_type_nelts (unsigned_char_type_node, +- i + off + last); +- RAW_DATA_OWNER (val) = owner; +- RAW_DATA_POINTER (val) = TREE_STRING_POINTER (owner) + off; +- init.value = val; +- set_c_expr_source_range (&init, loc, last_loc); +- init.original_code = RAW_DATA_CST; +- init.original_type = integer_type_node; +- init.m_decimal = 0; +- process_init_element (loc, init, false, braced_init_obstack); +- } + } + + /* Parse a compound statement (possibly a function body) (C90 6.6.2, +diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h +index bfdcb78bbcc1..e23d8e59ac4b 100644 +--- a/gcc/c/c-tree.h ++++ b/gcc/c/c-tree.h +@@ -832,7 +832,6 @@ extern struct c_expr pop_init_level (location_t, int, struct obstack *, + location_t); + extern void set_init_index (location_t, tree, tree, struct obstack *); + extern void set_init_label (location_t, tree, location_t, struct obstack *); +-unsigned c_maybe_optimize_large_byte_initializer (void); + extern void process_init_element (location_t, struct c_expr, bool, + struct obstack *); + extern tree build_compound_literal (location_t, tree, tree, bool, +diff --git a/gcc/c/c-typeck.cc b/gcc/c/c-typeck.cc +index 108ea5ca3e8c..36d0b23a3d72 100644 +--- a/gcc/c/c-typeck.cc ++++ b/gcc/c/c-typeck.cc +@@ -11347,42 +11347,6 @@ maybe_split_raw_data (tree value, tree *raw_data) + return value; + } + +-/* Return non-zero if c_parser_initval should attempt to optimize +- large initializers into RAW_DATA_CST. In that case return how +- many elements to optimize at most. */ +- +-unsigned +-c_maybe_optimize_large_byte_initializer (void) +-{ +- if (!constructor_type +- || TREE_CODE (constructor_type) != ARRAY_TYPE +- || constructor_stack->implicit) +- return 0; +- tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); +- if (TREE_CODE (elttype) != INTEGER_TYPE +- && TREE_CODE (elttype) != BITINT_TYPE) +- return 0; +- if (TYPE_PRECISION (elttype) != CHAR_BIT +- || constructor_stack->replacement_value.value +- || (COMPLETE_TYPE_P (constructor_type) +- && !poly_int_tree_p (TYPE_SIZE (constructor_type))) +- || constructor_range_stack) +- return 0; +- if (constructor_max_index == NULL_TREE) +- return INT_MAX; +- if (tree_int_cst_le (constructor_max_index, constructor_index) +- || integer_all_onesp (constructor_max_index)) +- return 0; +- widest_int w = wi::to_widest (constructor_max_index); +- w -= wi::to_widest (constructor_index); +- w += 1; +- if (w < 64) +- return 0; +- if (w > INT_MAX) +- return INT_MAX; +- return w.to_uhwi (); +-} +- + /* Add one non-braced element to the current constructor level. + This adjusts the current position within the constructor's type. + This may also start or terminate implicit levels +-- +2.47.0 +
