[llvm-dev] How the LLVM handle the debug location information of continue keyword and right brace(loop end location)?

[Frozen via llvm-dev]

Hi paulr:
    Thanks for your kindly response. Maybe I don't describe my question cleanly, let me show more information. From my side, I notice that whether we are in the continue keyword mode or we are in the right brace mode, the target of br instruction is the same, i.e. for loop

     Continue Keyword Mode:

; <label>:6:                                      ; preds = %3
  br label %7, !dbg !23


; <label>:7:                                      ; preds = %6
  %8 = load i32, i32* %2, align 4, !dbg !25
  %9 = add nsw i32 %8, 1, !dbg !25
  store i32 %9, i32* %2, align 4, !dbg !25
  br label %3, !dbg !27, !llvm.loop !28

   Right Brace Mode:
   ; <label>:6:                                      ; preds = %3
  br label %7, !dbg !23


; <label>:7:                                      ; preds = %6
  %8 = load i32, i32* %2, align 4, !dbg !25
  %9 = add nsw i32 %8, 1, !dbg !25
  store i32 %9, i32* %2, align 4, !dbg !25
  br label %3, !dbg !27, !llvm.loop !28


There are only different line number of !dbg!23. But my concern and question is:  Why continue keyword can be emitted but right brace won't be emitted, and debbuger can stop at continue keyword statement but won't stop at right brace statement? I know left / right brace is just to group and right brace statement should not be emitted debug location information. But the br instruction is the same and only has different line number information in the debug metadata, how the llvm distinguish this is meaningful statement and not right brace?



At 2017-06-03 02:50:13, "Robinson, Paul" <paul.robinson at sony.com> wrote:


The braces around the body of the 'for' statement indicate grouping, but don't have any other semantic significance.  If you look at the abstract syntax tree (AST) constructed for this by any compiler, it is highly unlikely to have an explicit representation of the braces, because the structure of the AST already describes the grouping.  On the other hand, a 'continue' statement will be explicitly represented in the AST because it is a statement in its own right.

 

If I modify your for-loop body to this:

 

  {

    i++;

#ifdef CONTINUE

    continue;

#endif

  }

 

and compile it both ways, then I see the same thing you do:  The generated IR is the same for both cases except for the source-location of the branch.  This makes sense to me as follows.

 

A 'for' loop has four parts: initialization, condition, increment, and body.  Clang emits the condition and increment parts in their own basic-blocks, for convenience.  This means it implicitly needs to add a branch at the end of the "body" block to the "increment" block.  However, if the "body" block already ends with an explicit branch (of any kind), then it can omit the implicit branch.  The 'continue' statement will obviously be generated as an explicit branch to the "increment" block.

 

The difference in debug-info is that the explicit branch is associated with the 'continue' statement, while the implicit branch is associated with the 'for' statement, and these statements have different source locations.  Even though the sequence of instructions is the same, the *reason* they were emitted is different, and the debug info reflects that difference.

--paulr

 

From: llvm-dev [mailto:llvm-dev-bounces at lists.llvm.org] On Behalf Of Frozen via llvm-dev
Sent: Friday, June 02, 2017 8:44 AM
To:llvm-dev at lists.llvm.org
Subject: [llvm-dev] How the LLVM handle the debug location information of continue keyword and right brace(loop end location)?

 

Let me show you the following simple C code:

int main()
{
  int i;
 
  for (i = 0; i < 256; i++)
  {
      i++;
  }
}

In this simple C code, if we use Clang to compile it and debug it: We will get something like this:

(gdb) b main
Breakpoint 1 at 0x100000f7b: file a.c, line 5.
(gdb) r
Starting program: a.out 
[New Thread 0x1403 of process 23435]
warning: unhandled dyld version (15)
 
Thread 2 hit Breakpoint 1, main () at a.c:5
5     for (i = 0; i < 256; i++)
(gdb) n
7         i++;
(gdb) 
5     for (i = 0; i < 256; i++)
(gdb) 
7         i++;

That is to say, the right brace of location LLVM doesn't emit. However if we have the continue keyword:

int main()
{
  int i;
 
  for (i = 0; i < 256; i++)
  {
    continue;
    i++;
  }
}

Then we compile and debug it:

Thread 2 hit Breakpoint 1, main () at a.c:5
5     for (i = 0; i < 256; i++)
(gdb) n
7       continue;
(gdb) 
5     for (i = 0; i < 256; i++)
(gdb) 
7       continue;
(gdb) 
5     for (i = 0; i < 256; i++)
(gdb) 
7       continue;

We will stop the line of continue. But if we compare the LLVM IR between them:

The right brace and continue keyword both are the following the br instruction and !dbg !23. Except that the line number of !dbg !23 not the same.

; :6: ; preds = %3 br label %7, !dbg !23

The question is how LLVM know whether to generate the debug location(generate for the continue keyword line, but not for the loop's right brace)? Because they are the same br instruction and others are the same.

 

 
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/llvm-dev/attachments/20170603/e96ee50e/attachment.html>