Reformat files.

[simon.giesecke]

Rebase to current main.

llvm/include/llvm/DebugInfo/DIContext.h

struct DILineInfo {
 
   bool operator==(const DILineInfo &RHS) const {
     return Line == RHS.Line && Column == RHS.Column &&
            FileName == RHS.FileName && FunctionName == RHS.FunctionName &&
            StartFileName == RHS.StartFileName && StartLine == RHS.StartLine &&
            Discriminator == RHS.Discriminator;
   }
 
-  bool operator!=(const DILineInfo &RHS) const {
-    return !(*this == RHS);
-  }
+  bool operator!=(const DILineInfo &RHS) const { return !(*this == RHS); }
 
   bool operator<(const DILineInfo &RHS) const {
     return std::tie(FileName, FunctionName, StartFileName, Line, Column,
                     StartLine, Discriminator) <
            std::tie(RHS.FileName, RHS.FunctionName, RHS.StartFileName, RHS.Line,
                     RHS.Column, RHS.StartLine, RHS.Discriminator);
   }
 

 
 /// A format-neutral container for inlined code description.
 class DIInliningInfo {
   SmallVector<DILineInfo, 4> Frames;
 
 public:
   DIInliningInfo() = default;
 
-  const DILineInfo & getFrame(unsigned Index) const {
+  const DILineInfo &getFrame(unsigned Index) const {
     assert(Index < Frames.size());
     return Frames[Index];
   }
 
   DILineInfo *getMutableFrame(unsigned Index) {
     assert(Index < Frames.size());
     return &Frames[Index];
   }
 
-  uint32_t getNumberOfFrames() const {
-    return Frames.size();
-  }
+  uint32_t getNumberOfFrames() const { return Frames.size(); }
 
-  void addFrame(const DILineInfo &Frame) {
-    Frames.push_back(Frame);
-  }
+  void addFrame(const DILineInfo &Frame) { Frames.push_back(Frame); }
 
-  void resize(unsigned i) {
-    Frames.resize(i);
-  }
+  void resize(unsigned i) { Frames.resize(i); }
 };
 
 /// Container for description of a global variable.
 struct DIGlobal {
   std::string Name;
   uint64_t Start = 0;
   uint64_t Size = 0;
 
#undef HANDLE_DWARF_SECTION
   DIDT_ID_UUID,
   DIDT_ID_Count
 };
 static_assert(DIDT_ID_Count <= 32, "section types overflow storage");
 
 /// Selects which debug sections get dumped.
 enum DIDumpType : unsigned {
   DIDT_Null,
-  DIDT_All             = ~0U,
+  DIDT_All = ~0U,
 #define HANDLE_DWARF_SECTION(ENUM_NAME, ELF_NAME, CMDLINE_NAME, OPTION)        \
   DIDT_##ENUM_NAME = 1U << DIDT_ID_##ENUM_NAME,
 #include "llvm/BinaryFormat/Dwarf.def"
 #undef HANDLE_DWARF_SECTION
   DIDT_UUID = 1 << DIDT_ID_UUID,
 };
 
 /// Container for dump options that control which debug information will be
struct DIDumpOptions {
 
   std::function<void(Error)> RecoverableErrorHandler =
       WithColor::defaultErrorHandler;
   std::function<void(Error)> WarningHandler = WithColor::defaultWarningHandler;
 };
 
 class DIContext {
 public:
-  enum DIContextKind {
-    CK_DWARF,
-    CK_PDB
-  };
+  enum DIContextKind { CK_DWARF, CK_PDB };
 
   DIContext(DIContextKind K) : Kind(K) {}
   virtual ~DIContext() = default;
 
   DIContextKind getKind() const { return Kind; }
 
   virtual void dump(raw_ostream &OS, DIDumpOptions DumpOpts) = 0;
 

 template <typename Derived, typename Base = LoadedObjectInfo>
 struct LoadedObjectInfoHelper : Base {
 protected:
   LoadedObjectInfoHelper(const LoadedObjectInfoHelper &) = default;
   LoadedObjectInfoHelper() = default;
 
 public:
   template <typename... Ts>
-  LoadedObjectInfoHelper(Ts &&... Args) : Base(std::forward<Ts>(Args)...) {}
+  LoadedObjectInfoHelper(Ts &&...Args) : Base(std::forward<Ts>(Args)...) {}
 
   std::unique_ptr<llvm::LoadedObjectInfo> clone() const override {
     return std::make_unique<Derived>(static_cast<const Derived &>(*this));
   }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DICONTEXT_H

llvm/include/llvm/DebugInfo/GSYM/LookupResult.h

 //===- LookupResult.h -------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H
 #define LLVM_DEBUGINFO_GSYM_LOOKUPRESULT_H
 
-#include "llvm/DebugInfo/GSYM/Range.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/DebugInfo/GSYM/Range.h"
 #include <inttypes.h>
 #include <vector>
 
 namespace llvm {
 class raw_ostream;
 namespace gsym {
 struct FileEntry;
 
 struct SourceLocation {
-  StringRef Name; ///< Function or symbol name.
-  StringRef Dir; ///< Line entry source file directory path.
-  StringRef Base; ///< Line entry source file basename.
-  uint32_t Line = 0; ///< Source file line number.
+  StringRef Name;      ///< Function or symbol name.
+  StringRef Dir;       ///< Line entry source file directory path.
+  StringRef Base;      ///< Line entry source file basename.
+  uint32_t Line = 0;   ///< Source file line number.
   uint32_t Offset = 0; ///< Byte size offset within the named function.
 };
 
 inline bool operator==(const SourceLocation &LHS, const SourceLocation &RHS) {
-  return LHS.Name == RHS.Name && LHS.Dir == RHS.Dir &&
-         LHS.Base == RHS.Base && LHS.Line == RHS.Line &&
-         LHS.Offset == RHS.Offset;
+  return LHS.Name == RHS.Name && LHS.Dir == RHS.Dir && LHS.Base == RHS.Base &&
+         LHS.Line == RHS.Line && LHS.Offset == RHS.Offset;
 }
 
 raw_ostream &operator<<(raw_ostream &OS, const SourceLocation &R);
 
 using SourceLocations = std::vector<SourceLocation>;
 
-
 struct LookupResult {
   uint64_t LookupAddr = 0; ///< The address that this lookup pertains to.
-  AddressRange FuncRange; ///< The concrete function address range.
+  AddressRange FuncRange;  ///< The concrete function address range.
   StringRef FuncName; ///< The concrete function name that contains LookupAddr.
   /// The source locations that match this address. This information will only
   /// be filled in if the FunctionInfo contains a line table. If an address is
   /// for a concrete function with no inlined functions, this array will have
   /// one entry. If an address points to an inline function, there will be one
   /// SourceLocation for each inlined function with the last entry pointing to
   /// the concrete function itself. This allows one address to generate
   /// multiple locations and allows unwinding of inline call stacks. The

llvm/include/llvm/DebugInfo/Symbolize/Symbolize.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
 #define LLVM_DEBUGINFO_SYMBOLIZE_SYMBOLIZE_H
 
 #include "llvm/DebugInfo/Symbolize/SymbolizableModule.h"
 #include "llvm/Object/Binary.h"
-#include "llvm/Object/ObjectFile.h"
 #include "llvm/Object/ELFObjectFile.h"
+#include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include <algorithm>
 #include <cstdint>
 #include <map>
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
struct Options {
     std::string FallbackDebugPath;
     std::string DWPName;
     std::vector<std::string> DebugFileDirectory;
   };
 
   LLVMSymbolizer() = default;
   LLVMSymbolizer(const Options &Opts) : Opts(Opts) {}
 
-  ~LLVMSymbolizer() {
-    flush();
-  }
+  ~LLVMSymbolizer() { flush(); }
 
   // Overloads accepting ObjectFile does not support COFF currently
   Expected<DILineInfo> symbolizeCode(const ObjectFile &Obj,
                                      object::SectionedAddress ModuleOffset);
   Expected<DILineInfo> symbolizeCode(const std::string &ModuleName,
                                      object::SectionedAddress ModuleOffset);
   Expected<DIInliningInfo>
   symbolizeInlinedCode(const ObjectFile &Obj,
private:
   /// Only one attempt is made to load a module, and errors during loading are
   /// only reported once. Subsequent calls to get module info for a module that
   /// failed to load will return nullptr.
   Expected<SymbolizableModule *>
   getOrCreateModuleInfo(const std::string &ModuleName);
   Expected<SymbolizableModule *> getOrCreateModuleInfo(const ObjectFile &Obj);
 
   Expected<SymbolizableModule *>
-  createModuleInfo(const ObjectFile *Obj,
-                   std::unique_ptr<DIContext> Context,
+  createModuleInfo(const ObjectFile *Obj, std::unique_ptr<DIContext> Context,
                    StringRef ModuleName);
 
   ObjectFile *lookUpDsymFile(const std::string &Path,
                              const MachOObjectFile *ExeObj,
                              const std::string &ArchName);
   ObjectFile *lookUpDebuglinkObject(const std::string &Path,
                                     const ObjectFile *Obj,
                                     const std::string &ArchName);
   ObjectFile *lookUpBuildIDObject(const std::string &Path,
                                   const ELFObjectFileBase *Obj,
                                   const std::string &ArchName);
 
   /// Returns pair of pointers to object and debug object.
   Expected<ObjectPair> getOrCreateObjectPair(const std::string &Path,
                                              const std::string &ArchName);
 
   /// Return a pointer to object file at specified path, for a specified
   /// architecture (e.g. if path refers to a Mach-O universal binary, only one
   /// object file from it will be returned).
   Expected<ObjectFile *> getOrCreateObject(const std::string &Path,
                                            const std::string &ArchName);
 
   std::map<std::string, std::unique_ptr<SymbolizableModule>, std::less<>>
       Modules;
 
   /// Contains cached results of getOrCreateObjectPair().
   std::map<std::pair<std::string, std::string>, ObjectPair>
       ObjectPairForPathArch;
 

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

 }
 
 namespace {
 
 // For Path="/path/to/foo" and Basename="foo" assume that debug info is in
 // /path/to/foo.dSYM/Contents/Resources/DWARF/foo.
 // For Path="/path/to/bar.dSYM" and Basename="foo" assume that debug info is in
 // /path/to/bar.dSYM/Contents/Resources/DWARF/foo.
-std::string getDarwinDWARFResourceForPath(
-    const std::string &Path, const std::string &Basename) {
+std::string getDarwinDWARFResourceForPath(const std::string &Path,
+                                          const std::string &Basename) {
   SmallString<16> ResourceName = StringRef(Path);
   if (sys::path::extension(Path) != ".dSYM") {
     ResourceName += ".dSYM";
   }
   sys::path::append(ResourceName, "Contents", "Resources", "DWARF");
   sys::path::append(ResourceName, Basename);
   return std::string(ResourceName.str());
 }
if (!PhdrsOrErr) {
     consumeError(PhdrsOrErr.takeError());
     return {};
   }
   for (const auto &P : *PhdrsOrErr) {
     if (P.p_type != ELF::PT_NOTE)
       continue;
     Error Err = Error::success();
     for (auto N : Obj.notes(P, Err))
-      if (N.getType() == ELF::NT_GNU_BUILD_ID && N.getName() == ELF::ELF_NOTE_GNU)
+      if (N.getType() == ELF::NT_GNU_BUILD_ID &&
+          N.getName() == ELF::ELF_NOTE_GNU)
         return N.getDesc();
     consumeError(std::move(Err));
   }
   return {};
 }
 
 Optional<ArrayRef<uint8_t>> getBuildID(const ELFObjectFileBase *Obj) {
   Optional<ArrayRef<uint8_t>> BuildID;
   if (auto *O = dyn_cast<ELFObjectFile<ELF32LE>>(Obj))
     BuildID = getBuildID(O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF32BE>>(Obj))
     BuildID = getBuildID(O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF64LE>>(Obj))
     BuildID = getBuildID(O->getELFFile());
   else if (auto *O = dyn_cast<ELFObjectFile<ELF64BE>>(Obj))
     BuildID = getBuildID(O->getELFFile());
   else
     llvm_unreachable("unsupported file format");
   return BuildID;
 }
 
 bool findDebugBinary(const std::vector<std::string> &DebugFileDirectory,
-                     const ArrayRef<uint8_t> BuildID,
-                     std::string &Result) {
+                     const ArrayRef<uint8_t> BuildID, std::string &Result) {
   auto getDebugPath = [&](StringRef Directory) {
     SmallString<128> Path{Directory};
     sys::path::append(Path, ".build-id",
                       llvm::toHex(BuildID[0], /*LowerCase=*/true),
                       llvm::toHex(BuildID.slice(1), /*LowerCase=*/true));
     Path += ".debug";
     return Path;
   };
   if (DebugFileDirectory.empty()) {
     SmallString<128> Path = getDebugPath(
 #if defined(__NetBSD__)
         // Try /usr/libdata/debug/.build-id/../...
         "/usr/libdata/debug"
 #else
         // Try /usr/lib/debug/.build-id/../...
         "/usr/lib/debug"
 #endif
     );
     if (llvm::sys::fs::exists(Path)) {
       Result = std::string(Path.str());
       return true;
     }
   } else {
     for (const auto &Directory : DebugFileDirectory) {
       // Try <debug-file-directory>/.build-id/../...
       SmallString<128> Path = getDebugPath(Directory);
       if (llvm::sys::fs::exists(Path)) {
         Result = std::string(Path.str());
         return true;
       }
     }
   }
   return false;
 }
 
 } // end anonymous namespace
 
 ObjectFile *LLVMSymbolizer::lookUpDsymFile(const std::string &ExePath,
-    const MachOObjectFile *MachExeObj, const std::string &ArchName) {
+                                           const MachOObjectFile *MachExeObj,
+                                           const std::string &ArchName) {
   // On Darwin we may find DWARF in separate object file in
   // resource directory.
   std::vector<std::string> DsymPaths;
   StringRef Filename = sys::path::filename(ExePath);
   DsymPaths.push_back(
       getDarwinDWARFResourceForPath(ExePath, std::string(Filename)));
   for (const auto &Path : Opts.DsymHints) {
     DsymPaths.push_back(

 
 std::string
 LLVMSymbolizer::DemangleName(const std::string &Name,
                              const SymbolizableModule *DbiModuleDescriptor) {
   // We can spoil names of symbols with C linkage, so use an heuristic
   // approach to check if the name should be demangled.
   if (Name.substr(0, 2) == "_Z") {
     int status = 0;
-    char *DemangledName = itaniumDemangle(Name.c_str(), nullptr, nullptr, &status);
+    char *DemangledName =
+        itaniumDemangle(Name.c_str(), nullptr, nullptr, &status);
     if (status != 0)
       return Name;
     std::string Result = DemangledName;
     free(DemangledName);
     return Result;
   }
 
   if (!Name.empty() && Name.front() == '?') {