From b9f4757f8eb94d4b145613ee5047f3f95452f9d2 Mon Sep 17 00:00:00 2001 From: David Malcolm Date: Tue, 10 Jan 2017 21:54:09 +0000 Subject: [PATCH] Fix issues with unrepresentable column numbers (PR c++/77949) PR c++/77949 identifies an ICE when the C++ frontend attempts to emit a fix-it hint inserting a missing semicolon at column 4097 of a source file. This column value exceeds LINE_MAP_MAX_COLUMN_NUMBER and hence isn't representable using a location_t. Attempting to do so leads to these problems, which this patch fixes: (a) when encountering a column number > LINE_MAP_MAX_COLUMN_NUMBER we create a new linemap with m_column_and_range_bits == 0, but linemap_position_for_column doesn't check for this, and hence can emit a bogus location_t value that's calculated relative to the previous linemap start, but which will be decoded relative to the new linemap, leading to very large incorrect line values. (b) when encountering a column number that can't be represented, and for which the linemap was pre-existing, the code would hit this assertion: if (linemap_assert_fails (column < (1u << map->m_column_and_range_bits))) around a bail-out condition. The patch replaces this assertion with a simple conditional, to stop the ICE when this occurs, and fixes the bit count (effective column bits, vs column+range bits) (c) the C++ frontend wasn't checking for failure of linemap_position_for_loc_and_offset when considering emitting the fix-it hint. The patch adds a conditional, so that no fix-it hint is emitted if the location is bogus. gcc/cp/ChangeLog: PR c++/77949 * parser.c (cp_parser_class_specifier_1): Only suggest inserting a missing semicolon if we have a valid insertion location for the fix-it hint. gcc/ChangeLog: PR c++/77949 * input.c (selftest::test_accessing_ordinary_linemaps): Verify that we correctly handle column numbers greater than LINE_MAP_MAX_COLUMN_NUMBER. gcc/testsuite/ChangeLog: PR c++/77949 * g++.dg/diagnostic/pr77949.C: New test case. libcpp/ChangeLog: PR c++/77949 * line-map.c (linemap_position_for_column): When calling linemap_start_line, detect if a new linemap was created with 0 column bits, and bail out early if this is the case. (linemap_position_for_loc_and_offset): Replace overzealous linemap_assert_fails with a simple conditional; use correct bit count. From-SVN: r244292 --- gcc/ChangeLog | 7 ++++++ gcc/cp/ChangeLog | 7 ++++++ gcc/cp/parser.c | 5 ++++- gcc/input.c | 26 +++++++++++++++++++++++ gcc/testsuite/ChangeLog | 5 +++++ gcc/testsuite/g++.dg/diagnostic/pr77949.C | 7 ++++++ libcpp/ChangeLog | 10 +++++++++ libcpp/line-map.c | 19 ++++++++++++++++- 8 files changed, 84 insertions(+), 2 deletions(-) create mode 100644 gcc/testsuite/g++.dg/diagnostic/pr77949.C diff --git a/gcc/ChangeLog b/gcc/ChangeLog index d0c53d066ea..ff8dac4eddd 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,10 @@ +2017-01-10 David Malcolm + + PR c++/77949 + * input.c (selftest::test_accessing_ordinary_linemaps): Verify + that we correctly handle column numbers greater than + LINE_MAP_MAX_COLUMN_NUMBER. + 2017-01-10 Martin Sebor PR tree-optimization/78775 diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 25f5a85db92..892651a7eeb 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,10 @@ +2017-01-10 David Malcolm + + PR c++/77949 + * parser.c (cp_parser_class_specifier_1): Only suggest inserting + a missing semicolon if we have a valid insertion location for + the fix-it hint. + 2017-01-10 Jason Merrill FI 20, decomposition declaration with parenthesized initializer. diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 45173131ee9..7b3ee30345e 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -22164,7 +22164,10 @@ cp_parser_class_specifier_1 (cp_parser* parser) next_loc = linemap_position_for_loc_and_offset (line_table, loc, 1); rich_location richloc (line_table, next_loc); - richloc.add_fixit_insert_before (next_loc, ";"); + + /* If we successfully offset the location, suggest the fix-it. */ + if (next_loc != loc) + richloc.add_fixit_insert_before (next_loc, ";"); if (CLASSTYPE_DECLARED_CLASS (type)) error_at_rich_loc (&richloc, diff --git a/gcc/input.c b/gcc/input.c index bbb6abb8878..3e67314932a 100644 --- a/gcc/input.c +++ b/gcc/input.c @@ -1699,6 +1699,22 @@ test_accessing_ordinary_linemaps (const line_table_case &case_) ASSERT_EQ (7, map->m_column_and_range_bits - map->m_range_bits); } + /* Example of a line that will eventually be seen to be longer + than LINE_MAP_MAX_COLUMN_NUMBER; the initially seen width is + below that. */ + linemap_line_start (line_table, 5, 2000); + + location_t loc_start_of_very_long_line + = linemap_position_for_column (line_table, 2000); + location_t loc_too_wide + = linemap_position_for_column (line_table, 4097); + location_t loc_too_wide_2 + = linemap_position_for_column (line_table, 4098); + + /* ...and back to a sane line length. */ + linemap_line_start (line_table, 6, 100); + location_t loc_sane_again = linemap_position_for_column (line_table, 10); + linemap_add (line_table, LC_LEAVE, false, NULL, 0); /* Multiple files. */ @@ -1714,6 +1730,16 @@ test_accessing_ordinary_linemaps (const line_table_case &case_) assert_loceq ("foo.c", 2, 17, loc_d); assert_loceq ("foo.c", 3, 700, loc_e); assert_loceq ("foo.c", 4, 100, loc_back_to_short); + + /* In the very wide line, the initial location should be fully tracked. */ + assert_loceq ("foo.c", 5, 2000, loc_start_of_very_long_line); + /* ...but once we exceed LINE_MAP_MAX_COLUMN_NUMBER column-tracking should + be disabled. */ + assert_loceq ("foo.c", 5, 0, loc_too_wide); + assert_loceq ("foo.c", 5, 0, loc_too_wide_2); + /*...and column-tracking should be re-enabled for subsequent lines. */ + assert_loceq ("foo.c", 6, 10, loc_sane_again); + assert_loceq ("bar.c", 1, 150, loc_f); ASSERT_FALSE (is_location_from_builtin_token (loc_a)); diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index f8cba4221ab..59a2fcfbef4 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,8 @@ +2017-01-10 David Malcolm + + PR c++/77949 + * g++.dg/diagnostic/pr77949.C: New test case. + 2017-01-10 Martin Sebor PR tree-optimization/78775 diff --git a/gcc/testsuite/g++.dg/diagnostic/pr77949.C b/gcc/testsuite/g++.dg/diagnostic/pr77949.C new file mode 100644 index 00000000000..0d8b333a2ad --- /dev/null +++ b/gcc/testsuite/g++.dg/diagnostic/pr77949.C @@ -0,0 +1,7 @@ +// Ensure that no fix-it hints are emitted +// { dg-options "-fdiagnostics-parseable-fixits" } + +/* Very long line, where a missing semicolon would be suggested for + insertion at column 4097. */ +class test { } +// { dg-error "0: expected .;. after class definition" "" { target *-*-* } .-1 } diff --git a/libcpp/ChangeLog b/libcpp/ChangeLog index 082291d5648..208e1d52e6f 100644 --- a/libcpp/ChangeLog +++ b/libcpp/ChangeLog @@ -1,3 +1,13 @@ +2017-01-10 David Malcolm + + PR c++/77949 + * line-map.c (linemap_position_for_column): When calling + linemap_start_line, detect if a new linemap was created with + 0 column bits, and bail out early if this is the case. + (linemap_position_for_loc_and_offset): Replace overzealous + linemap_assert_fails with a simple conditional; use correct + bit count. + 2017-01-07 David Malcolm PR c++/72803 diff --git a/libcpp/line-map.c b/libcpp/line-map.c index b410c00e367..949489eb1a1 100644 --- a/libcpp/line-map.c +++ b/libcpp/line-map.c @@ -816,8 +816,22 @@ linemap_position_for_column (struct line_maps *set, unsigned int to_column) } else { + /* Otherwise, attempt to start a new line that can hold TO_COLUMN, + with some space to spare. This may or may not lead to a new + linemap being created. */ line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set); r = linemap_line_start (set, SOURCE_LINE (map, r), to_column + 50); + map = LINEMAPS_LAST_ORDINARY_MAP (set); + if (map->m_column_and_range_bits == 0) + { + /* ...then the linemap has column-tracking disabled, + presumably due to exceeding either + LINE_MAP_MAX_LOCATION_WITH_COLS (overall) or + LINE_MAP_MAX_COLUMN_NUMBER (within this line). + Return the start of the linemap, which encodes column 0, for + the whole line. */ + return r; + } } } line_map_ordinary *map = LINEMAPS_LAST_ORDINARY_MAP (set); @@ -905,7 +919,10 @@ linemap_position_for_loc_and_offset (struct line_maps *set, } column += column_offset; - if (linemap_assert_fails (column < (1u << map->m_column_and_range_bits))) + + /* Bail out if the column is not representable within the existing + linemap. */ + if (column >= (1u << (map->m_column_and_range_bits - map->m_range_bits))) return loc; source_location r =