[llvm] [DebugInfo] getMergedLocation: match scopes based on their location (PR #132286)

[Vladislav Dzhidzhoev via llvm-commits]

dzhidzhoev wrote:

I'll paste the example from the previous comment here to put everything in one place.

z1.c:

```
  # 100 "z1.c" 1
  i += a;
  i -= 10*a;
  i *= a*a;
```

z2.c:

```
  # 200 "z2.c" 1
  i += a;
  i -= 10*a;
  i *= a*a;
```

y.c:
```
  # 300 "y.c" 1
  do {
  #ifdef A
  #include "z1.c"
  #else
  #include "z2.c"
  #endif
  } while (0);
```

main.c:

```
int foo(int a) {
  int i = 0;
  if ((a & 1) == 1) {
    a -= 1;
#define A
#include "y.c"
 } else {
    a += 3;
#undef A
#include "y.c"
 }
  return i;
}
```

Let's consider the DILocations of `i *= a*a;` from `z1.c:102` (L1) and `i *= a*a;` from `z2.c:202` (L2). They are being merged.

We have the following parent scopes chain for L1, discovered by GetNearestCommonScope:
```
!6  =          !DILocation(line: 102, column: 3, scope: !7)
!7  =          !DILexicalBlockFile(scope: !9,  file: !8,  discriminator: 0)
!9  = distinct !DILexicalBlock    (scope: !11, file: !10, line: 300, column: 4)
!11 =          !DILexicalBlockFile(scope: !12, file: !10, discriminator: 0)
!12 = distinct !DILexicalBlock    (scope: !13, file: !1,  line: 3, column: 21)
!13 = distinct !DILexicalBlock    (scope: !3,  file: !1,  line: 3, column: 7)
!3  = distinct !DISubprogram      (name: "foo", scope: !1, file: !1, line: 1)

!8 =  !DIFile(filename: "z1.c", directory: "")
!10 = !DIFile(filename: "y.c", directory: "")
!1 =  !DIFile(filename: "main.c", directory: "")
```

The parent scopes chain for L2 looks like that:
```
!14 =          !DILocation(line: 202, column: 3, scope: !15)
!15 =          !DILexicalBlockFile(scope: !17, file: !16, discriminator: 0)
!17 = distinct !DILexicalBlock    (scope: !18, file: !10, line: 300, column: 4)
!18 =          !DILexicalBlockFile(scope: !19, file: !10, discriminator: 0)
!19 = distinct !DILexicalBlock    (scope: !13, file: !1, line: 7, column: 9)
!13 = distinct !DILexicalBlock    (scope: !3, file: !1, line: 3, column: 7)
!3  = distinct !DISubprogram      (name: "foo", scope: !1, file: !1, line: 1)

!16 = !DIFile(filename: "z2.c", directory: "")
!10 = !DIFile(filename: "y.c", directory: "")
!1 =  !DIFile(filename: "main.c", directory: "")
```

The current implementation stores a pointer to every scope from L1's chain into `Scopes` set. Then, it goes over the parent scopes chain of L2 until it finds a DIScope* that is contained in `Scopes` set. In this example, it is `!13`. It is taken as a parent scope for the output DILocation. Since L1's and L2's line numbers don't match, the output is `!DILocation(line: 0, scope: !13)`.

With the proposed PR, every scope from L1's chain will be put in `Scopes` map. The key of the map is the scope's file, line number, and column number tuple. For DILexicalBlockFiles, the line number of a previous scope in the chain is used as a location (since DILexicalBlockFile doesn't have line or column fields). For this example, the map will look like this:
```
Scopes[{!8,  102, 0}] = {!7}
Scopes[{!10, 300, 4}] = {!9}
Scopes[{!10, 300, 0}] = {!11}
Scopes[{!1, 3, 21}] = {!12}
Scopes[{!1, 3, 7}] = {!13}
Scopes[{!1, 1, 0}] = {!3}
```

Then, it goes over L2's parent scopes chain, and for every scope S from L2's chain, it determines if there is a scope with the same key in `Scopes`. If the scope with the same key is found, two options are considered:
1. scope S is present in `Scopes` => return S.
2. scope S is not present in `Scopes` => return any scope from `Scopes` with the same key as the key for S.

In our example, the following keys are examined until a suitable scope is found:
```
Scope !15 - Key {!16, 202, 0}
Scope !17 - Key {!10, 300, 4}
```

```
Scopes[{!10, 300, 4}] = {!9}
```
Thus, scope !9 is considered as an output for GetNearestCommonScope.

After `Scope = GetNearestCommonScope(L1, L2)` call, getMergedLocation checks if `L1->getFile()`, `L2->getFile()`, `Scope->getFile()` are pairwise equal.
1. If all files are equal, it means there are scopes S1 and S2 from L1 and L2 parent scopes chains correspondingly, which have the same line number, column number, and file as S has. We use S as a parent scope for output location. Output line number and column number are derived from L1, L2 (if they match).
2. If files are not equal, a case of "#include" into function body is assumed. L1 and L2 locations are ingored, the output of getMergedLocation() is the location of S.

In the given example, the output location will be `!DILocation(line: 300, column: 4, scope: !9)`.



> The chains are still a bit confusing to me in the example - perhaps use specific instructions, and their scope chain? (some instruction should have a single scope link, which continues up until it reaches the function - so I don't quite understand the function with up and down arrows, and sideways arrows)

(arrows go from parent scopes to children)

https://github.com/llvm/llvm-project/pull/132286