Next iteration of the algorithm

Author: dzhidzhoev

llvm/lib/IR/DebugInfoMetadata.cpp

@@ -125,6 +125,14 @@ DILocation *DILocation::getMergedLocations(ArrayRef<DILocation *> Locs) {
   return Merged;
 }
 
+static DILexicalBlockBase *cloneAndReplaceParentScope(DILexicalBlockBase *LBB,
+                                                      DIScope *NewParent) {
+  TempMDNode ClonedScope = LBB->clone();
+  cast<DILexicalBlockBase>(*ClonedScope).replaceScope(NewParent);
+  return cast<DILexicalBlockBase>(
+      MDNode::replaceWithUniqued(std::move(ClonedScope)));
+}
+
 using LineColumn = std::pair<unsigned /* Line */, unsigned /* Column */>;
 
 /// Returns the location of DILocalScope, if present, or a default value.
@@ -141,6 +149,82 @@ static LineColumn getLocalScopeLocationOr(DIScope *S, LineColumn Default) {
   llvm_unreachable("Unhandled type of DILocalScope.");
 }
 
+// Returns the nearest matching scope inside a subprogram.
+template <typename MatcherT>
+static std::pair<DIScope *, LineColumn>
+getNearestMatchingScope(const DILocation *L1, const DILocation *L2) {
+  MatcherT Matcher;
+
+  DIScope *S1 = L1->getScope();
+  DIScope *S2 = L2->getScope();
+
+  // When matching DILexicalBlockFile's, ignore column numbers, so that
+  // DILocation's having different columns within the same
+  // DILexicalBlockFile will match.
+  auto GetLocForBlockFile = [](LineColumn L) {
+    L.second = 0;
+    return L;
+  };
+
+  LineColumn Loc1(L1->getLine(), L1->getColumn());
+  for (; S1; S1 = S1->getScope()) {
+    Loc1 = getLocalScopeLocationOr(S1, GetLocForBlockFile(Loc1));
+    Matcher.insert(S1, Loc1);
+    if (isa<DISubprogram>(S1))
+      break;
+  }
+
+  LineColumn Loc2(L2->getLine(), L2->getColumn());
+  for (; S2; S2 = S2->getScope()) {
+    Loc2 = getLocalScopeLocationOr(S2, GetLocForBlockFile(Loc2));
+
+    if (DIScope *S = Matcher.match(S2, Loc2))
+      return std::make_pair(S, Loc2);
+
+    if (isa<DISubprogram>(S2))
+      break;
+  }
+  return std::make_pair(nullptr, LineColumn(L2->getLine(), L2->getColumn()));
+}
+
+// Matches equal scopes.
+struct EqualScopesMatcher {
+  SmallPtrSet<DIScope *, 8> Scopes;
+
+  void insert(DIScope *S, LineColumn Loc) { Scopes.insert(S); }
+
+  DIScope *match(DIScope *S, LineColumn Loc) {
+    return Scopes.contains(S) ? S : nullptr;
+  }
+};
+
+// Matches scopes with the same location.
+struct ScopeLocationsMatcher {
+  SmallMapVector<std::pair<DIFile *, LineColumn>, SmallSetVector<DIScope *, 8>,
+                 8>
+      Scopes;
+
+  void insert(DIScope *S, LineColumn Loc) {
+    Scopes[{S->getFile(), Loc}].insert(S);
+  }
+
+  DIScope *match(DIScope *S, LineColumn Loc) {
+    auto ScopesAtLoc = Scopes.find({S->getFile(), Loc});
+    // No scope found with the given location.
+    if (ScopesAtLoc == Scopes.end())
+      return nullptr;
+
+    // Prefer S over other scopes with the same location.
+    if (ScopesAtLoc->second.contains(S))
+      return S;
+
+    if (!ScopesAtLoc->second.empty())
+      return *ScopesAtLoc->second.begin();
+
+    llvm_unreachable("Scopes must not have empty entries.");
+  }
+};
+
 DILocation *DILocation::getMergedLocation(DILocation *LocA, DILocation *LocB) {
   if (!LocA || !LocB)
     return nullptr;
@@ -224,66 +308,29 @@ DILocation *DILocation::getMergedLocation(DILocation *LocA, DILocation *LocB) {
     if (L1->getScope()->getSubprogram() != L2->getScope()->getSubprogram())
       return nullptr;
 
-    // Return the nearest common scope inside a subprogram.
-    auto GetNearestCommonScope =
-        [](const DILocation *L1,
-           const DILocation *L2) -> std::pair<DIScope *, LineColumn> {
-      DIScope *S1 = L1->getScope();
-      DIScope *S2 = L2->getScope();
-
-      SmallMapVector<std::pair<DIFile *, LineColumn>,
-                     SmallSetVector<DIScope *, 8>, 8>
-          Scopes;
-
-      // When matching DILexicalBlockFile's, ignore column numbers, so that
-      // DILocation's having different columns within the same
-      // DILexicalBlockFile will match.
-      auto getLocForBlockFile = [](LineColumn L) {
-        L.second = 0;
-        return L;
-      };
-
-      LineColumn Loc1(L1->getLine(), L1->getColumn());
-      for (; S1; S1 = S1->getScope()) {
-        Loc1 = getLocalScopeLocationOr(S1, getLocForBlockFile(Loc1));
-        Scopes[{S1->getFile(), Loc1}].insert(S1);
-
-        if (isa<DISubprogram>(S1))
-          break;
-      }
-
-      LineColumn Loc2(L2->getLine(), L2->getColumn());
-      for (; S2; S2 = S2->getScope()) {
-        Loc2 = getLocalScopeLocationOr(S2, getLocForBlockFile(Loc2));
-
-        auto ScopesAtLoc = Scopes.find({S2->getFile(), Loc2});
-        // No scope found with the same file, line and column as S2.
-        if (ScopesAtLoc == Scopes.end())
-          continue;
-
-        // Return S2 if it is L1's parent.
-        if (ScopesAtLoc->second.contains(S2))
-          return std::make_pair(S2, Loc2);
-
-        // Return any L1's parent with the same file, line and column as S2.
-        if (!ScopesAtLoc->second.empty())
-          return std::make_pair(*ScopesAtLoc->second.begin(), Loc2);
-
-        if (isa<DISubprogram>(S2))
-          break;
-      }
-
-      return std::make_pair(nullptr,
-                            LineColumn(L2->getLine(), L2->getColumn()));
-    };
-
-    auto [Scope, ScopeLoc] = GetNearestCommonScope(L1, L2);
+    // Find nearest common scope inside subprogram.
+    DIScope *Scope = getNearestMatchingScope<EqualScopesMatcher>(L1, L2).first;
     assert(Scope && "No common scope in the same subprogram?");
 
-    // Use inclusion location if files are different.
+    // Try using the nearest scope with common location if files are different.
     if (Scope->getFile() != L1->getFile() || L1->getFile() != L2->getFile()) {
-      return DILocation::get(C, ScopeLoc.first, ScopeLoc.second, Scope,
-                             InlinedAt);
+      auto [CommonLocScope, CommonLoc] =
+          getNearestMatchingScope<ScopeLocationsMatcher>(L1, L2);
+
+      // If CommonLocScope is a DILexicalBlockBase, clone it and locate
+      // a new scope inside the nearest common scope to preserve
+      // lexical blocks structure.
+      if (auto *LBB = dyn_cast<DILexicalBlockBase>(CommonLocScope);
+          LBB && LBB != Scope)
+        CommonLocScope = cloneAndReplaceParentScope(LBB, Scope);
+
+      Scope = CommonLocScope;
+
+      // If files are still different, assume that L1 and L2 were "included"
+      // from CommonLoc. Use it as merged location.
+      if (Scope->getFile() != L1->getFile() || L1->getFile() != L2->getFile())
+        return DILocation::get(C, CommonLoc.first, CommonLoc.second,
+                               CommonLocScope, InlinedAt);
     }
 
     bool SameLine = L1->getLine() == L2->getLine();
@@ -1243,10 +1290,8 @@ DILocalScope *DILocalScope::cloneScopeForSubprogram(
   // cached result).
   DIScope *UpdatedScope = CachedResult ? CachedResult : &NewSP;
   for (DIScope *ScopeToUpdate : reverse(ScopeChain)) {
-    TempMDNode ClonedScope = ScopeToUpdate->clone();
-    cast<DILexicalBlockBase>(*ClonedScope).replaceScope(UpdatedScope);
-    UpdatedScope =
-        cast<DIScope>(MDNode::replaceWithUniqued(std::move(ClonedScope)));
+    UpdatedScope = cloneAndReplaceParentScope(
+        cast<DILexicalBlockBase>(ScopeToUpdate), UpdatedScope);
     Cache[ScopeToUpdate] = UpdatedScope;
   }
 

llvm/test/DebugInfo/AArch64/merge-nested-block-loc.ll

@@ -74,7 +74,6 @@ if.end:                                           ; preds = %if.else, %if.then
 ; CHECK: [[SP:![0-9]+]] = distinct !DISubprogram(name: "foo", scope: [[FILE1:![0-9]+]], file: [[FILE1]], line: 1
 ; CHECK: [[FILE1]] = !DIFile(filename: "1.c", directory: "")
 ; CHECK: [[PHILOC]] = !DILocation(line: 42, column: 3, scope: [[LBF:![0-9]+]])
-; CHECK: [[LBF]] = !DILexicalBlockFile(scope: [[LB1:![0-9]+]], file: [[FILE2:![0-9]+]], discriminator: 0)
+; CHECK: [[LBF]] = !DILexicalBlockFile(scope: [[LB:![0-9]+]], file: [[FILE2:![0-9]+]], discriminator: 0)
 ; CHECK: [[FILE2]] = !DIFile(filename: "m.c", directory: "")
-; CHECK: [[LB1]] = distinct !DILexicalBlock(scope: [[LB2:![0-9]+]], file: [[FILE1]], line: 3, column: 21)
-; CHECK: [[LB2]] = distinct !DILexicalBlock(scope: [[SP]], file: [[FILE1]], line: 3, column: 7)
+; CHECK: [[LB]] = distinct !DILexicalBlock(scope: [[SP]], file: [[FILE1]], line: 3, column: 7)

llvm/test/DebugInfo/AArch64/merge-nested-block-loc2.ll

@@ -125,8 +125,6 @@ if.end:                                           ; preds = %if.else, %do.body
 ; CHECK: [[FILE_MAIN:![0-9]+]] = !DIFile(filename: "main.c"
 ; CHECK: [[SP:![0-9]+]] = distinct !DISubprogram(name: "foo", scope: [[FILE_MAIN]], file: [[FILE_MAIN]], line: 1
 ; CHECK: [[PHILOC]] = !DILocation(line: 300, column: 4, scope: [[BLOCK_Y:![0-9]+]])
-; CHECK-NEXT: [[BLOCK_Y]] = distinct !DILexicalBlock(scope: [[LBF_Y:![0-9]+]], file: [[FILE_Y:![0-9]+]], line: 300, column: 4)
+; CHECK-NEXT: [[BLOCK_Y]] = !DILexicalBlock(scope: [[BLOCK_MAIN:![0-9]+]], file: [[FILE_Y:![0-9]+]], line: 300, column: 4)
 ; CHECK-NEXT: [[FILE_Y]] = !DIFile(filename: "y.c"
-; CHECK: [[LBF_Y]] = !DILexicalBlockFile(scope: [[BLOCK2_MAIN:![0-9]+]], file: [[FILE_Y]], discriminator: 0)
-; CHECK-NEXT: [[BLOCK2_MAIN]] = distinct !DILexicalBlock(scope: [[BLOCK1_MAIN:![0-9]+]], file: [[FILE_MAIN]], line: 3, column: 21)
-; CHECK: [[BLOCK1_MAIN]] = distinct !DILexicalBlock(scope: [[SP]], file: [[FILE_MAIN]], line: 3, column: 7)
+; CHECK: [[BLOCK_MAIN]] = distinct !DILexicalBlock(scope: [[SP]], file: [[FILE_MAIN]], line: 3, column: 7)

llvm/unittests/IR/MetadataTest.cpp

@@ -1000,9 +1000,9 @@ TEST_F(DILocationTest, Merge) {
     auto *A = DILocation::get(Context, 1, 6, LBF);
     auto *B = DILocation::get(Context, 2, 7, LBF);
     auto *M = DILocation::getMergedLocation(A, B);
-    EXPECT_EQ(3u, M->getLine());
-    EXPECT_EQ(4u, M->getColumn());
-    EXPECT_EQ(S, M->getScope());
+    EXPECT_EQ(0u, M->getLine());
+    EXPECT_EQ(0u, M->getColumn());
+    EXPECT_EQ(LBF, M->getScope());
   }
 
   {
@@ -1084,10 +1084,15 @@ TEST_F(DILocationTest, Merge) {
     auto *LBF2 = DILexicalBlockFile::get(Context, LB2, F2, 0);
     auto *A = DILocation::get(Context, 1, 6, LBF1);
     auto *B = DILocation::get(Context, 1, 6, LBF2);
+    llvm::errs() << "Check\n";
     auto *M = DILocation::getMergedLocation(A, B);
+    M->dump();
+    M->getScope()->dump();
+    LBF1->dump();
     EXPECT_EQ(1u, M->getLine());
     EXPECT_EQ(6u, M->getColumn());
-    EXPECT_EQ(LBF1, M->getScope());
+    EXPECT_EQ(LBF1->getFile(), M->getScope()->getFile());
+    EXPECT_EQ(N, M->getScope()->getScope());
   }
 
   {
@@ -1167,9 +1172,13 @@ TEST_F(DILocationTest, Merge) {
     auto *A = DILocation::get(Context, 41, 7, Block2[0]);
     auto *B = DILocation::get(Context, 51, 8, Block2[1]);
     auto *M = DILocation::getMergedLocation(A, B);
+    auto *MScope = dyn_cast<DILexicalBlock>(M->getScope());
     EXPECT_EQ(30u, M->getLine());
     EXPECT_EQ(4u, M->getColumn());
-    EXPECT_EQ(Block1[0], M->getScope());
+    EXPECT_EQ(Block1[0]->getFile(), MScope->getFile());
+    EXPECT_EQ(Block1[0]->getLine(), MScope->getLine());
+    EXPECT_EQ(Block1[0]->getColumn(), MScope->getColumn());
+    EXPECT_EQ(LBCommon, MScope->getScope());
   }
 
   {