diff mbox series

c++: Fix scan forward over pragma [PR96257]

Message ID 7a9c3b23-9af2-20a1-93f5-097ac06674f1@acm.org
State New
Headers show
Series c++: Fix scan forward over pragma [PR96257] | expand

Commit Message

Nathan Sidwell July 21, 2020, 7:43 p.m. UTC 
It turns out that the paren scanning code is used for speculatively 
searching to see if we're looking at a compound_literal.  So we 
shouldn't always purge pragma tokens.

             gcc/cp/
             * parser.c (cp_lexer_consume_token): Drop PRAGMA_EOL assert.
             (cp_parser_skip_to_closing_parenthesis_1): Only pass start 
token
             to pragma skipper if recovering.
             (cp_parser_skip_to_pragma_eol): Only purge and change pragma
             state when recovering.
             gcc/testsuite/
             * g++.dg/parse/pr96257.C: New.

pushed
diff mbox series

Patch

diff --git c/gcc/cp/parser.c w/gcc/cp/parser.c
index 11db02418bc..5a2d73d1ab0 100644
--- c/gcc/cp/parser.c
+++ w/gcc/cp/parser.c
@@ -1121,8 +1121,6 @@  cp_lexer_consume_token (cp_lexer* lexer)
 {
   cp_token *token = lexer->next_token;
 
-  gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL);
-
   do
     {
       gcc_assert (token->type != CPP_EOF);
@@ -3691,7 +3689,7 @@  cp_parser_skip_to_closing_parenthesis_1 (cp_parser *parser,
 
 	case CPP_PRAGMA:
 	  /* We fell into a pragma.  Skip it, and continue. */
-	  cp_parser_skip_to_pragma_eol (parser, token);
+	  cp_parser_skip_to_pragma_eol (parser, recovering ? token : nullptr);
 	  continue;
 
 	default:
@@ -3930,15 +3928,14 @@  cp_parser_skip_to_closing_brace (cp_parser *parser)
 
 /* Consume tokens until we reach the end of the pragma.  The PRAGMA_TOK
    parameter is the PRAGMA token, allowing us to purge the entire pragma
-   sequence.  */
+   sequence.  PRAGMA_TOK can be NULL, if we're speculatively scanning
+   forwards (not error recovery).  */
 
 static void
 cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
 {
   cp_token *token;
 
-  parser->lexer->in_pragma = false;
-
   do
     {
       /* The preprocessor makes sure that a PRAGMA_EOL token appears
@@ -3950,8 +3947,12 @@  cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
     }
   while (token->type != CPP_PRAGMA_EOL);
 
-  /* Ensure that the pragma is not parsed again.  */
-  cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
+  if (pragma_tok)
+    {
+      /* Ensure that the pragma is not parsed again.  */
+      cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
+      parser->lexer->in_pragma = false;
+    }
 }
 
 /* Require pragma end of line, resyncing with it as necessary.  The
diff --git c/gcc/testsuite/g++.dg/parse/pr96257.C w/gcc/testsuite/g++.dg/parse/pr96257.C
new file mode 100644
index 00000000000..34b0208c5d7
--- /dev/null
+++ w/gcc/testsuite/g++.dg/parse/pr96257.C
@@ -0,0 +1,18 @@ 
+// PR96257 we scan forwards checking for a compound literal.  Do not
+// eat the tokens when doing that!
+/* { dg-require-effective-target fopenmp } */
+/* { dg-additional-options -fopenmp }  */
+
+int
+f2 ()
+{
+  int s = (int // { dg-error "expected" }
+#pragma omp atomic capture
+       ){1};
+
+  int t = (int // { dg-error "expected" }
+#pragma omp atomic capture ){
+    {1};
+
+    return s + t;
+} // { dg-bogus "expected" }