Merge branch 'main' into fix-misreport-progress

Author: zeyi2

bolt/lib/Core/BinaryContext.cpp

@@ -1888,6 +1888,9 @@ void BinaryContext::preprocessDebugInfo() {
 
   preprocessDWODebugInfo();
 
+  // Check if required DWO files are missing.
+  uint64_t NumMissingDWOs = 0;
+
   // Populate MCContext with DWARF files from all units.
   StringRef GlobalPrefix = AsmInfo->getPrivateGlobalPrefix();
   for (const std::unique_ptr<DWARFUnit> &CU : DwCtx->compile_units()) {
@@ -1909,19 +1912,23 @@ void BinaryContext::preprocessDebugInfo() {
       std::optional<MD5::MD5Result> Checksum;
       if (LineTable->Prologue.ContentTypes.HasMD5)
         Checksum = LineTable->Prologue.FileNames[0].Checksum;
-      std::optional<const char *> Name =
+      const char *Name =
           dwarf::toString(CU->getUnitDIE().find(dwarf::DW_AT_name), nullptr);
       if (std::optional<uint64_t> DWOID = CU->getDWOId()) {
         auto Iter = DWOCUs.find(*DWOID);
         if (Iter == DWOCUs.end()) {
-          this->errs() << "BOLT-ERROR: DWO CU was not found for " << Name
-                       << '\n';
-          exit(1);
+          const char *DWOName =
+              dwarf::toString(CU->getUnitDIE().find(dwarf::DW_AT_dwo_name),
+                              "<missing DW_AT_dwo_name>");
+          this->errs() << "BOLT-ERROR: unable to load " << DWOName
+                       << " for DWO_id 0x" << Twine::utohexstr(*DWOID) << '\n';
+          NumMissingDWOs++;
+          continue;
         }
         Name = dwarf::toString(
             Iter->second->getUnitDIE().find(dwarf::DW_AT_name), nullptr);
       }
-      BinaryLineTable.setRootFile(CU->getCompilationDir(), *Name, Checksum,
+      BinaryLineTable.setRootFile(CU->getCompilationDir(), Name, Checksum,
                                   std::nullopt);
     }
 
@@ -1956,6 +1963,14 @@ void BinaryContext::preprocessDebugInfo() {
                             DwarfVersion));
     }
   }
+
+  if (NumMissingDWOs) {
+    this->errs() << "BOLT-ERROR: " << NumMissingDWOs
+                 << " required DWO file(s) not found. Unable to update debug"
+                    " info. Use --comp-dir-override to locate the file(s) or"
+                    " --update-debug-sections=0 to remove debug info\n";
+    exit(1);
+  }
 }
 
 bool BinaryContext::shouldEmit(const BinaryFunction &Function) const {

bolt/test/dwarf5-missing-dwo.c

@@ -0,0 +1,18 @@
+// Check that llvm-bolt correctly reports a missing DWO file while updating
+// debug info.
+//
+// RUN: %clang %cflags -g -dwarf5 -gsplit-dwarf=single -c %s -o %t.o
+// RUN: %clang %cflags %t.o -o %t.exe -Wl,-q
+// RUN: rm %t.o
+// RUN: not llvm-bolt %t.exe -o %t.bolt --update-debug-sections \
+// RUN:   2>&1 | FileCheck %s -DDWO=%t.o
+//
+// Check that llvm-bolt succeeds on the same binary with disabled debug info
+// update.
+//
+// RUN: llvm-bolt %t.exe -o %t.bolt --update-debug-sections=0
+
+// CHECK:      BOLT-ERROR: unable to load [[DWO]]
+// CHECK-NEXT: BOLT-ERROR: 1 required DWO file(s) not found
+
+int main() { return 0; }

clang-tools-extra/clang-doc/JSONGenerator.cpp

@@ -84,8 +84,23 @@ serializeLocation(const Location &Loc,
   return LocationObj;
 }
 
+/// Insert comments into a key in the Description object.
+///
+/// \param Comment Either an Object or Array, depending on the comment type
+/// \param Key     The type (Brief, Code, etc.) of comment to be inserted
 static void insertComment(Object &Description, json::Value &Comment,
                           StringRef Key) {
+  // The comment has a Children array for the actual text, with meta attributes
+  // alongside it in the Object.
+  if (auto *Obj = Comment.getAsObject()) {
+    if (auto *Children = Obj->getArray("Children"); Children->empty())
+      return;
+  }
+  // The comment is just an array of text comments.
+  else if (auto *Array = Comment.getAsArray(); Array->empty()) {
+    return;
+  }
+
   auto DescriptionIt = Description.find(Key);
 
   if (DescriptionIt == Description.end()) {
@@ -98,10 +113,28 @@ static void insertComment(Object &Description, json::Value &Comment,
   }
 }
 
+/// Takes the nested "Children" array from a comment Object.
+///
+/// \return a json::Array of comments, possible json::Value::Kind::Null
 static json::Value extractTextComments(Object *ParagraphComment) {
   if (!ParagraphComment)
-    return json::Object();
-  return *ParagraphComment->get("Children");
+    return json::Value(nullptr);
+  json::Value *Children = ParagraphComment->get("Children");
+  if (!Children)
+    return json::Value(nullptr);
+  auto ChildrenArray = *Children->getAsArray();
+  auto ChildrenIt = ChildrenArray.begin();
+  while (ChildrenIt != ChildrenArray.end()) {
+    auto *ChildObj = ChildrenIt->getAsObject();
+    assert(ChildObj && "Invalid JSON object in Comment");
+    auto TextComment = ChildObj->getString("TextComment");
+    if (!TextComment || TextComment->empty()) {
+      ChildrenIt = ChildrenArray.erase(ChildrenIt);
+      continue;
+    }
+    ++ChildrenIt;
+  }
+  return ChildrenArray;
 }
 
 static json::Value extractVerbatimComments(json::Array VerbatimLines) {
@@ -131,7 +164,8 @@ static Object serializeComment(const CommentInfo &I, Object &Description) {
 
   switch (I.Kind) {
   case CommentKind::CK_TextComment: {
-    Obj.insert({commentKindToString(I.Kind), I.Text});
+    if (!I.Text.empty())
+      Obj.insert({commentKindToString(I.Kind), I.Text});
     return Obj;
   }
 
@@ -265,6 +299,9 @@ serializeCommonAttributes(const Info &I, json::Object &Obj,
       if (auto *ParagraphComment = Comment.getAsObject();
           ParagraphComment->get("ParagraphComment")) {
         auto TextCommentsArray = extractTextComments(ParagraphComment);
+        if (TextCommentsArray.kind() == json::Value::Null ||
+            TextCommentsArray.getAsArray()->empty())
+          continue;
         insertComment(Description, TextCommentsArray, "ParagraphComments");
       }
     }

clang-tools-extra/clangd/ClangdLSPServer.cpp

@@ -554,8 +554,6 @@ void ClangdLSPServer::onInitialize(const InitializeParams &Params,
     if (const auto &Dir = Params.initializationOptions.compilationDatabasePath)
       CDBOpts.CompileCommandsDir = Dir;
     CDBOpts.ContextProvider = Opts.ContextProvider;
-    if (Opts.StrongWorkspaceMode)
-      CDBOpts.applyFallbackWorkingDirectory(Opts.WorkspaceRoot);
     BaseCDB =
         std::make_unique<DirectoryBasedGlobalCompilationDatabase>(CDBOpts);
   }

clang-tools-extra/clangd/ClangdServer.h

@@ -152,11 +152,6 @@ class ClangdServer {
     /// FIXME: If not set, should use the current working directory.
     std::optional<std::string> WorkspaceRoot;
 
-    /// Sets an alternate mode of operation. Current effects are:
-    /// - Using the current working directory as the working directory for
-    ///   fallback commands
-    bool StrongWorkspaceMode;
-
     /// The resource directory is used to find internal headers, overriding
     /// defaults and -resource-dir compiler flag).
     /// If std::nullopt, ClangdServer calls

clang-tools-extra/clangd/GlobalCompilationDatabase.cpp

@@ -64,9 +64,7 @@ GlobalCompilationDatabase::getFallbackCommand(PathRef File) const {
   if (FileExtension.empty() || FileExtension == ".h")
     Argv.push_back("-xobjective-c++-header");
   Argv.push_back(std::string(File));
-  tooling::CompileCommand Cmd(FallbackWorkingDirectory
-                                  ? *FallbackWorkingDirectory
-                                  : llvm::sys::path::parent_path(File),
+  tooling::CompileCommand Cmd(llvm::sys::path::parent_path(File),
                               llvm::sys::path::filename(File), std::move(Argv),
                               /*Output=*/"");
   Cmd.Heuristic = "clangd fallback";
@@ -351,8 +349,7 @@ bool DirectoryBasedGlobalCompilationDatabase::DirectoryCache::load(
 
 DirectoryBasedGlobalCompilationDatabase::
     DirectoryBasedGlobalCompilationDatabase(const Options &Opts)
-    : GlobalCompilationDatabase(Opts.FallbackWorkingDirectory), Opts(Opts),
-      Broadcaster(std::make_unique<BroadcastThread>(*this)) {
+    : Opts(Opts), Broadcaster(std::make_unique<BroadcastThread>(*this)) {
   if (!this->Opts.ContextProvider)
     this->Opts.ContextProvider = [](llvm::StringRef) {
       return Context::current().clone();
@@ -463,21 +460,6 @@ DirectoryBasedGlobalCompilationDatabase::lookupCDB(
   return Result;
 }
 
-void DirectoryBasedGlobalCompilationDatabase::Options::
-    applyFallbackWorkingDirectory(
-        std::optional<std::string> FallbackWorkingDirectory) {
-  if (FallbackWorkingDirectory)
-    this->FallbackWorkingDirectory = *FallbackWorkingDirectory;
-  else {
-    // Clangd is running in strong workspace mode but the client didn't
-    // specify a workspace path in the `initialize` request.
-    // Fallback to current working directory.
-    SmallString<256> CWD;
-    llvm::sys::fs::current_path(CWD);
-    this->FallbackWorkingDirectory = std::string(CWD);
-  }
-}
-
 // The broadcast thread announces files with new compile commands to the world.
 // Primarily this is used to enqueue them for background indexing.
 //
@@ -777,10 +759,9 @@ DirectoryBasedGlobalCompilationDatabase::getProjectModules(PathRef File) const {
 
 OverlayCDB::OverlayCDB(const GlobalCompilationDatabase *Base,
                        std::vector<std::string> FallbackFlags,
-                       CommandMangler Mangler,
-                       std::optional<std::string> FallbackWorkingDirectory)
-    : DelegatingCDB(Base, FallbackWorkingDirectory),
-      Mangler(std::move(Mangler)), FallbackFlags(std::move(FallbackFlags)) {}
+                       CommandMangler Mangler)
+    : DelegatingCDB(Base), Mangler(std::move(Mangler)),
+      FallbackFlags(std::move(FallbackFlags)) {}
 
 std::optional<tooling::CompileCommand>
 OverlayCDB::getCompileCommand(PathRef File) const {
@@ -863,20 +844,16 @@ OverlayCDB::getProjectModules(PathRef File) const {
   return MDB;
 }
 
-DelegatingCDB::DelegatingCDB(
-    const GlobalCompilationDatabase *Base,
-    std::optional<std::string> FallbackWorkingDirectory)
-    : GlobalCompilationDatabase(FallbackWorkingDirectory), Base(Base) {
+DelegatingCDB::DelegatingCDB(const GlobalCompilationDatabase *Base)
+    : Base(Base) {
   if (Base)
     BaseChanged = Base->watch([this](const std::vector<std::string> Changes) {
       OnCommandChanged.broadcast(Changes);
     });
 }
 
-DelegatingCDB::DelegatingCDB(
-    std::unique_ptr<GlobalCompilationDatabase> Base,
-    std::optional<std::string> FallbackWorkingDirectory)
-    : DelegatingCDB(Base.get(), FallbackWorkingDirectory) {
+DelegatingCDB::DelegatingCDB(std::unique_ptr<GlobalCompilationDatabase> Base)
+    : DelegatingCDB(Base.get()) {
   BaseOwner = std::move(Base);
 }
 

clang-tools-extra/clangd/GlobalCompilationDatabase.h

@@ -35,9 +35,6 @@ struct ProjectInfo {
 /// Provides compilation arguments used for parsing C and C++ files.
 class GlobalCompilationDatabase {
 public:
-  GlobalCompilationDatabase(
-      std::optional<std::string> FallbackWorkingDirectory = std::nullopt)
-      : FallbackWorkingDirectory(FallbackWorkingDirectory) {}
   virtual ~GlobalCompilationDatabase() = default;
 
   /// If there are any known-good commands for building this file, returns one.
@@ -72,19 +69,14 @@ class GlobalCompilationDatabase {
   }
 
 protected:
-  std::optional<std::string> FallbackWorkingDirectory;
   mutable CommandChanged OnCommandChanged;
 };
 
 // Helper class for implementing GlobalCompilationDatabases that wrap others.
 class DelegatingCDB : public GlobalCompilationDatabase {
 public:
-  DelegatingCDB(
-      const GlobalCompilationDatabase *Base,
-      std::optional<std::string> FallbackWorkingDirectory = std::nullopt);
-  DelegatingCDB(
-      std::unique_ptr<GlobalCompilationDatabase> Base,
-      std::optional<std::string> FallbackWorkingDirectory = std::nullopt);
+  DelegatingCDB(const GlobalCompilationDatabase *Base);
+  DelegatingCDB(std::unique_ptr<GlobalCompilationDatabase> Base);
 
   std::optional<tooling::CompileCommand>
   getCompileCommand(PathRef File) const override;
@@ -125,12 +117,6 @@ class DirectoryBasedGlobalCompilationDatabase
     // Only look for a compilation database in this one fixed directory.
     // FIXME: fold this into config/context mechanism.
     std::optional<Path> CompileCommandsDir;
-    // Working directory for fallback commands
-    // If unset, parent directory of file should be used
-    std::optional<std::string> FallbackWorkingDirectory;
-
-    void applyFallbackWorkingDirectory(
-        std::optional<std::string> FallbackWorkingDirectory);
   };
 
   DirectoryBasedGlobalCompilationDatabase(const Options &Opts);
@@ -208,11 +194,9 @@ class OverlayCDB : public DelegatingCDB {
   // Base may be null, in which case no entries are inherited.
   // FallbackFlags are added to the fallback compile command.
   // Adjuster is applied to all commands, fallback or not.
-  OverlayCDB(
-      const GlobalCompilationDatabase *Base,
-      std::vector<std::string> FallbackFlags = {},
-      CommandMangler Mangler = nullptr,
-      std::optional<std::string> FallbackWorkingDirectory = std::nullopt);
+  OverlayCDB(const GlobalCompilationDatabase *Base,
+             std::vector<std::string> FallbackFlags = {},
+             CommandMangler Mangler = nullptr);
 
   std::optional<tooling::CompileCommand>
   getCompileCommand(PathRef File) const override;

clang-tools-extra/clangd/tool/Check.cpp

@@ -169,8 +169,6 @@ class Checker {
   bool buildCommand(const ThreadsafeFS &TFS) {
     log("Loading compilation database...");
     DirectoryBasedGlobalCompilationDatabase::Options CDBOpts(TFS);
-    if (Opts.StrongWorkspaceMode)
-      CDBOpts.applyFallbackWorkingDirectory(Opts.WorkspaceRoot);
     CDBOpts.CompileCommandsDir =
         Config::current().CompileFlags.CDBSearch.FixedCDBPath;
     BaseCDB =
@@ -180,10 +178,8 @@ class Checker {
         getSystemIncludeExtractor(llvm::ArrayRef(Opts.QueryDriverGlobs));
     if (Opts.ResourceDir)
       Mangler.ResourceDir = *Opts.ResourceDir;
-
     CDB = std::make_unique<OverlayCDB>(
-        BaseCDB.get(), std::vector<std::string>{}, std::move(Mangler),
-        CDBOpts.FallbackWorkingDirectory);
+        BaseCDB.get(), std::vector<std::string>{}, std::move(Mangler));
 
     if (auto TrueCmd = CDB->getCompileCommand(File)) {
       Cmd = std::move(*TrueCmd);
@@ -506,7 +502,7 @@ bool check(llvm::StringRef File, const ThreadsafeFS &TFS,
                  config::DiagnosticCallback Diag) const override {
       config::Fragment F;
       // If we're timing clang-tidy checks, implicitly disabling the slow ones
-      // is counterproductive!
+      // is counterproductive! 
       if (CheckTidyTime.getNumOccurrences())
         F.Diagnostics.ClangTidy.FastCheckFilter.emplace("None");
       return {std::move(F).compile(Diag)};

clang-tools-extra/clangd/tool/ClangdMain.cpp

@@ -500,17 +500,6 @@ opt<bool> EnableConfig{
     init(true),
 };
 
-opt<bool> StrongWorkspaceMode{
-    "strong-workspace-mode",
-    cat(Features),
-    desc("An alternate mode of operation for clangd, where the clangd instance "
-         "is used to edit a single workspace.\n"
-         "When enabled, fallback commands use the workspace directory as their "
-         "working directory instead of the parent folder."),
-    init(false),
-    Hidden,
-};
-
 opt<bool> UseDirtyHeaders{"use-dirty-headers", cat(Misc),
                           desc("Use files open in the editor when parsing "
                                "headers instead of reading from the disk"),
@@ -918,7 +907,6 @@ clangd accepts flags on the commandline, and in the CLANGD_FLAGS environment var
   }
   if (!ResourceDir.empty())
     Opts.ResourceDir = ResourceDir;
-  Opts.StrongWorkspaceMode = StrongWorkspaceMode;
   Opts.BuildDynamicSymbolIndex = true;
 #if CLANGD_ENABLE_REMOTE
   if (RemoteIndexAddress.empty() != ProjectRoot.empty()) {

clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp

@@ -55,20 +55,6 @@ TEST(GlobalCompilationDatabaseTest, FallbackCommand) {
                                            testPath("foo/bar")));
 }
 
-TEST(GlobalCompilationDatabaseTest, FallbackWorkingDirectory) {
-  MockFS TFS;
-  DirectoryBasedGlobalCompilationDatabase::Options CDBOpts(TFS);
-  CDBOpts.applyFallbackWorkingDirectory(testPath("foo"));
-  EXPECT_EQ(CDBOpts.FallbackWorkingDirectory, testPath("foo"));
-
-  DirectoryBasedGlobalCompilationDatabase DB(CDBOpts);
-  auto Cmd = DB.getFallbackCommand(testPath("foo/src/bar.cc"));
-  EXPECT_EQ(Cmd.Directory, testPath("foo"));
-  EXPECT_THAT(Cmd.CommandLine,
-              ElementsAre("clang", testPath("foo/src/bar.cc")));
-  EXPECT_EQ(Cmd.Output, "");
-}
-
 static tooling::CompileCommand cmd(llvm::StringRef File, llvm::StringRef Arg) {
   return tooling::CompileCommand(
       testRoot(), File, {"clang", std::string(Arg), std::string(File)}, "");