re PR debug/90197 (Cannot step through simple loop at -O -g)

	PR debug/90197
	* c-tree.h (c_finish_loop): Add 2 further location_t arguments.
	* c-parser.c (c_parser_while_statement): Adjust c_finish_loop caller.
	(c_parser_do_statement): Likewise.
	(c_parser_for_statement): Likewise.  Formatting fixes.
	* c-typeck.c (c_finish_loop): Add COND_LOCUS and INCR_LOCUS arguments,
	emit DEBUG_BEGIN_STMTs if needed.

From-SVN: r270606

diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog
index e5bc2b753030496a80acccbdbd9a04a9d18d9ca9..ef192bf64a4859271de2d6c9b58038d6da5a2095 100644 (file)
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,13 @@
+2019-04-26  Jakub Jelinek  <jakub@redhat.com>
+
+       PR debug/90197
+       * c-tree.h (c_finish_loop): Add 2 further location_t arguments.
+       * c-parser.c (c_parser_while_statement): Adjust c_finish_loop caller.
+       (c_parser_do_statement): Likewise.
+       (c_parser_for_statement): Likewise.  Formatting fixes.
+       * c-typeck.c (c_finish_loop): Add COND_LOCUS and INCR_LOCUS arguments,
+       emit DEBUG_BEGIN_STMTs if needed.
+
 2019-04-19  Jakub Jelinek  <jakub@redhat.com>
 
        PR c/89888

diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c
index 741d172ff307f44030c0e70705c76e3a2e5cbd4d..854cd6ce8c60ef096f61f91326123f559a85a533 100644 (file)
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -6001,7 +6001,8 @@ c_parser_while_statement (c_parser *parser, bool ivdep, unsigned short unroll,
   location_t loc_after_labels;
   bool open_brace = c_parser_next_token_is (parser, CPP_OPEN_BRACE);
   body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
-  c_finish_loop (loc, cond, NULL, body, c_break_label, c_cont_label, true);
+  c_finish_loop (loc, loc, cond, UNKNOWN_LOCATION, NULL, body,
+                c_break_label, c_cont_label, true);
   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
   c_parser_maybe_reclassify_token (parser);
 
@@ -6046,6 +6047,7 @@ c_parser_do_statement (c_parser *parser, bool ivdep, unsigned short unroll)
   c_break_label = save_break;
   new_cont = c_cont_label;
   c_cont_label = save_cont;
+  location_t cond_loc = c_parser_peek_token (parser)->location;
   cond = c_parser_paren_condition (parser);
   if (ivdep && cond != error_mark_node)
     cond = build3 (ANNOTATE_EXPR, TREE_TYPE (cond), cond,
@@ -6059,7 +6061,8 @@ c_parser_do_statement (c_parser *parser, bool ivdep, unsigned short unroll)
                   build_int_cst (integer_type_node, unroll));
   if (!c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
     c_parser_skip_to_end_of_block_or_statement (parser);
-  c_finish_loop (loc, cond, NULL, body, new_break, new_cont, false);
+  c_finish_loop (loc, cond_loc, cond, UNKNOWN_LOCATION, NULL, body,
+                new_break, new_cont, false);
   add_stmt (c_end_compound_stmt (loc, block, flag_isoc99));
 }
 
@@ -6132,7 +6135,9 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
   /* Silence the bogus uninitialized warning.  */
   tree collection_expression = NULL;
   location_t loc = c_parser_peek_token (parser)->location;
-  location_t for_loc = c_parser_peek_token (parser)->location;
+  location_t for_loc = loc;
+  location_t cond_loc = UNKNOWN_LOCATION;
+  location_t incr_loc = UNKNOWN_LOCATION;
   bool is_foreach_statement = false;
   gcc_assert (c_parser_next_token_is_keyword (parser, RID_FOR));
   token_indent_info for_tinfo
@@ -6166,7 +6171,8 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
              c_parser_consume_token (parser);
              is_foreach_statement = true;
              if (check_for_loop_decls (for_loc, true) == NULL_TREE)
-               c_parser_error (parser, "multiple iterating variables in fast enumeration");
+               c_parser_error (parser, "multiple iterating variables in "
+                                       "fast enumeration");
            }
          else
            check_for_loop_decls (for_loc, flag_isoc99);
@@ -6196,7 +6202,8 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
                  c_parser_consume_token (parser);
                  is_foreach_statement = true;
                  if (check_for_loop_decls (for_loc, true) == NULL_TREE)
-                   c_parser_error (parser, "multiple iterating variables in fast enumeration");
+                   c_parser_error (parser, "multiple iterating variables in "
+                                           "fast enumeration");
                }
              else
                check_for_loop_decls (for_loc, flag_isoc99);
@@ -6218,15 +6225,18 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
                c_parser_consume_token (parser);
                is_foreach_statement = true;
                if (! lvalue_p (init_expression))
-                 c_parser_error (parser, "invalid iterating variable in fast enumeration");
-               object_expression = c_fully_fold (init_expression, false, NULL);
+                 c_parser_error (parser, "invalid iterating variable in "
+                                         "fast enumeration");
+               object_expression
+                 = c_fully_fold (init_expression, false, NULL);
              }
            else
              {
                ce = convert_lvalue_to_rvalue (loc, ce, true, false);
                init_expression = ce.value;
                c_finish_expr_stmt (loc, init_expression);
-               c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
+               c_parser_skip_until_found (parser, CPP_SEMICOLON,
+                                          "expected %<;%>");
              }
          }
        }
@@ -6235,18 +6245,19 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
       gcc_assert (!parser->objc_could_be_foreach_context);
       if (!is_foreach_statement)
        {
+         cond_loc = c_parser_peek_token (parser)->location;
          if (c_parser_next_token_is (parser, CPP_SEMICOLON))
            {
              if (ivdep)
                {
-                 c_parser_error (parser, "missing loop condition in loop with "
-                                 "%<GCC ivdep%> pragma");
+                 c_parser_error (parser, "missing loop condition in loop "
+                                         "with %<GCC ivdep%> pragma");
                  cond = error_mark_node;
                }
              else if (unroll)
                {
-                 c_parser_error (parser, "missing loop condition in loop with "
-                                 "%<GCC unroll%> pragma");
+                 c_parser_error (parser, "missing loop condition in loop "
+                                         "with %<GCC unroll%> pragma");
                  cond = error_mark_node;
                }
              else
@@ -6275,11 +6286,13 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
       /* Parse the increment expression (the third expression in a
         for-statement).  In the case of a foreach-statement, this is
         the expression that follows the 'in'.  */
+      loc = incr_loc = c_parser_peek_token (parser)->location;
       if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
        {
          if (is_foreach_statement)
            {
-             c_parser_error (parser, "missing collection in fast enumeration");
+             c_parser_error (parser,
+                             "missing collection in fast enumeration");
              collection_expression = error_mark_node;
            }
          else
@@ -6288,8 +6301,8 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
       else
        {
          if (is_foreach_statement)
-           collection_expression = c_fully_fold (c_parser_expression (parser).value,
-                                                 false, NULL);
+           collection_expression
+             = c_fully_fold (c_parser_expression (parser).value, false, NULL);
          else
            {
              struct c_expr ce = c_parser_expression (parser);
@@ -6312,10 +6325,14 @@ c_parser_for_statement (c_parser *parser, bool ivdep, unsigned short unroll,
   body = c_parser_c99_block_statement (parser, if_p, &loc_after_labels);
 
   if (is_foreach_statement)
-    objc_finish_foreach_loop (loc, object_expression, collection_expression, body, c_break_label, c_cont_label);
+    objc_finish_foreach_loop (for_loc, object_expression,
+                             collection_expression, body, c_break_label,
+                             c_cont_label);
   else
-    c_finish_loop (loc, cond, incr, body, c_break_label, c_cont_label, true);
-  add_stmt (c_end_compound_stmt (loc, block, flag_isoc99 || c_dialect_objc ()));
+    c_finish_loop (for_loc, cond_loc, cond, incr_loc, incr, body,
+                  c_break_label, c_cont_label, true);
+  add_stmt (c_end_compound_stmt (for_loc, block,
+                                flag_isoc99 || c_dialect_objc ()));
   c_parser_maybe_reclassify_token (parser);
 
   token_indent_info next_tinfo

diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h
index 9393f6d15454a44dd5183ca20f4d805e61008af8..7e35ab1f0bcfe7ece008788547e29261592899f4 100644 (file)
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -694,7 +694,8 @@ extern int c_types_compatible_p (tree, tree);
 extern tree c_begin_compound_stmt (bool);
 extern tree c_end_compound_stmt (location_t, tree, bool);
 extern void c_finish_if_stmt (location_t, tree, tree, tree);
-extern void c_finish_loop (location_t, tree, tree, tree, tree, tree, bool);
+extern void c_finish_loop (location_t, location_t, tree, location_t, tree,
+                          tree, tree, tree, bool);
 extern tree c_begin_stmt_expr (void);
 extern tree c_finish_stmt_expr (location_t, tree);
 extern tree c_process_expr_stmt (location_t, tree);

diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c
index 8286b7d33298afcc60bf4f0d33533b8cd8f96fcf..4e4437540028ee53110aeeb89c6f8c5812097687 100644 (file)
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -10858,11 +10858,14 @@ c_finish_if_stmt (location_t if_locus, tree cond, tree then_block,
    the beginning of the loop.  COND is the loop condition.  COND_IS_FIRST
    is false for DO loops.  INCR is the FOR increment expression.  BODY is
    the statement controlled by the loop.  BLAB is the break label.  CLAB is
-   the continue label.  Everything is allowed to be NULL.  */
+   the continue label.  Everything is allowed to be NULL.
+   COND_LOCUS is the location of the loop condition, INCR_LOCUS is the
+   location of the FOR increment expression.  */
 
 void
-c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
-              tree blab, tree clab, bool cond_is_first)
+c_finish_loop (location_t start_locus, location_t cond_locus, tree cond,
+              location_t incr_locus, tree incr, tree body, tree blab,
+              tree clab, bool cond_is_first)
 {
   tree entry = NULL, exit = NULL, t;
 
@@ -10904,12 +10907,8 @@ c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
            }
 
          t = build_and_jump (&blab);
-         if (cond_is_first)
-           exit = fold_build3_loc (start_locus,
-                               COND_EXPR, void_type_node, cond, exit, t);
-         else
-           exit = fold_build3_loc (input_location,
-                               COND_EXPR, void_type_node, cond, exit, t);
+         exit = fold_build3_loc (cond_is_first ? start_locus : input_location,
+                                 COND_EXPR, void_type_node, cond, exit, t);
        }
       else
        {
@@ -10930,9 +10929,23 @@ c_finish_loop (location_t start_locus, tree cond, tree incr, tree body,
   if (clab)
     add_stmt (build1 (LABEL_EXPR, void_type_node, clab));
   if (incr)
-    add_stmt (incr);
+    {
+      if (MAY_HAVE_DEBUG_MARKER_STMTS && incr_locus != UNKNOWN_LOCATION)
+       {
+         t = build0 (DEBUG_BEGIN_STMT, void_type_node);
+         SET_EXPR_LOCATION (t, incr_locus);
+         add_stmt (t);
+       }
+      add_stmt (incr);
+    }
   if (entry)
     add_stmt (entry);
+  if (MAY_HAVE_DEBUG_MARKER_STMTS && cond_locus != UNKNOWN_LOCATION)
+    {
+      t = build0 (DEBUG_BEGIN_STMT, void_type_node);
+      SET_EXPR_LOCATION (t, cond_locus);
+      add_stmt (t);
+    }
   if (exit)
     add_stmt (exit);
   if (blab)