From d2b9548f38c77edc29ab0e24e516f1fb341ecea7 Mon Sep 17 00:00:00 2001 From: Jason Merrill Date: Thu, 30 Jan 2020 18:49:29 -0500 Subject: [PATCH] c++: Reduce memory consumption for large static arrays. PR14179 and the C counterpart PR12245 are about memory consumption of very large file-scope arrays. Recently, location wrappers increased memory consumption significantly: in an array of integer constants, each one will have a location wrapper, which added up to over 500MB in the 14179 testcase. For this kind of testcase tracking these locations isn't worth the cost, so this patch turns the wrappers off after 256 elements; any array that size or larger isn't likely to be interested in the location of individual integer constants. PR c++/14179 * parser.c (cp_parser_initializer_list): Suppress location wrappers after 256 elements. --- gcc/cp/ChangeLog | 6 ++++++ gcc/cp/parser.c | 18 ++++++++++++++++++ 2 files changed, 24 insertions(+) diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index f260d5d..f814088 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,9 @@ +2020-01-31 Jason Merrill + + PR c++/14179 + * parser.c (cp_parser_initializer_list): Suppress location wrappers + after 256 elements. + 2020-01-29 Jason Merrill PR c++/82521 diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index bd8e524..e0f7230 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -23311,6 +23311,9 @@ cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p, /* Assume all of the expressions are constant. */ *non_constant_p = false; + unsigned nelts = 0; + int suppress = suppress_location_wrappers; + /* Parse the rest of the list. */ while (true) { @@ -23450,6 +23453,19 @@ cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p, if (token->type == CPP_CLOSE_BRACE) break; + /* Suppress location wrappers in a long initializer to save memory + (14179). The cutoff is chosen arbitrarily. */ + const unsigned loc_max = 256; + unsigned incr = 1; + if (TREE_CODE (initializer) == CONSTRUCTOR) + /* Look one level down because it's easy. Looking deeper would require + passing down a nelts pointer, and I don't think multi-level massive + initializers are common enough to justify this. */ + incr = CONSTRUCTOR_NELTS (initializer); + nelts += incr; + if (nelts >= loc_max && (nelts - incr) < loc_max) + ++suppress_location_wrappers; + /* Consume the `,' token. */ cp_lexer_consume_token (parser->lexer); } @@ -23479,6 +23495,8 @@ cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p, IDENTIFIER_MARKED (designator) = 0; } + suppress_location_wrappers = suppress; + *designated = first_designator != NULL_TREE; return v; } -- 2.7.4