[LLVMSymbolize] Move printing the description of a global into a separate function. NFC.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@251669 91177308-0d34-0410-b5e6-96231b3b80d8

Author: vonosmas

include/llvm/DebugInfo/DIContext.h

@@ -65,6 +65,15 @@ class DIInliningInfo {
   }
 };
 
+/// DIGlobal - container for description of a global variable.
+struct DIGlobal {
+  std::string Name;
+  uint64_t Start;
+  uint64_t Size;
+
+  DIGlobal() : Name("<invalid>"), Start(0), Size(0) {}
+};
+
 /// A DINameKind is passed to name search methods to specify a
 /// preference regarding the type of name resolution the caller wants.
 enum class DINameKind { None, ShortName, LinkageName };

include/llvm/DebugInfo/Symbolize/SymbolizableModule.h

@@ -37,8 +37,7 @@ class SymbolizableModule {
   virtual DIInliningInfo symbolizeInlinedCode(uint64_t ModuleOffset,
                                               FunctionNameKind FNKind,
                                               bool UseSymbolTable) const = 0;
-  virtual bool symbolizeData(uint64_t ModuleOffset, std::string &Name,
-                             uint64_t &Start, uint64_t &Size) const = 0;
+  virtual DIGlobal symbolizeData(uint64_t ModuleOffset) const = 0;
 
   // Return true if this is a 32-bit x86 PE COFF module.
   virtual bool isWin32Module() const = 0;

include/llvm/DebugInfo/Symbolize/Symbolize.h

@@ -80,6 +80,8 @@ class LLVMSymbolizer {
 
   std::string printDILineInfo(DILineInfo LineInfo,
                               const SymbolizableModule *ModInfo) const;
+  std::string printDIGlobal(DIGlobal Global,
+                            const SymbolizableModule *ModInfo) const;
 
   // Owns all the parsed binaries and object files.
   SmallVector<std::unique_ptr<Binary>, 4> ParsedBinariesAndObjects;

lib/DebugInfo/Symbolize/SymbolizableObjectFile.cpp

@@ -239,11 +239,11 @@ DIInliningInfo SymbolizableObjectFile::symbolizeInlinedCode(
   return PatchedInlinedContext;
 }
 
-bool SymbolizableObjectFile::symbolizeData(uint64_t ModuleOffset,
-                                           std::string &Name, uint64_t &Start,
-                                           uint64_t &Size) const {
-  return getNameFromSymbolTable(SymbolRef::ST_Data, ModuleOffset, Name, Start,
-                                Size);
+DIGlobal SymbolizableObjectFile::symbolizeData(uint64_t ModuleOffset) const {
+  DIGlobal Res;
+  getNameFromSymbolTable(SymbolRef::ST_Data, ModuleOffset, Res.Name, Res.Start,
+                         Res.Size);
+  return Res;
 }
 
 }  // namespace symbolize

lib/DebugInfo/Symbolize/SymbolizableObjectFile.h

@@ -33,8 +33,7 @@ class SymbolizableObjectFile : public SymbolizableModule {
   DIInliningInfo symbolizeInlinedCode(uint64_t ModuleOffset,
                                       FunctionNameKind FNKind,
                                       bool UseSymbolTable) const override;
-  bool symbolizeData(uint64_t ModuleOffset, std::string &Name, uint64_t &Start,
-                     uint64_t &Size) const override;
+  DIGlobal symbolizeData(uint64_t ModuleOffset) const override;
 
   // Return true if this is a 32-bit x86 PE COFF module.
   bool isWin32Module() const override;

lib/DebugInfo/Symbolize/Symbolize.cpp

@@ -56,6 +56,10 @@ static bool error(std::error_code ec) {
 }
 
 
+// By default, DILineInfo contains "<invalid>" for function/filename it
+// cannot fetch. We replace it to "??" to make our output closer to addr2line.
+static const char kDILineInfoBadString[] = "<invalid>";
+
 const char LLVMSymbolizer::kBadString[] = "??";
 
 std::string LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
@@ -88,23 +92,18 @@ std::string LLVMSymbolizer::symbolizeCode(const std::string &ModuleName,
 
 std::string LLVMSymbolizer::symbolizeData(const std::string &ModuleName,
                                           uint64_t ModuleOffset) {
-  std::string Name = kBadString;
-  uint64_t Start = 0;
-  uint64_t Size = 0;
   if (Opts.UseSymbolTable) {
     if (SymbolizableModule *Info = getOrCreateModuleInfo(ModuleName)) {
       // If the user is giving us relative addresses, add the preferred base of
       // the object to the offset before we do the query. It's what DIContext
       // expects.
       if (Opts.RelativeAddresses)
         ModuleOffset += Info->getModulePreferredBase();
-      if (Info->symbolizeData(ModuleOffset, Name, Start, Size) && Opts.Demangle)
-        Name = DemangleName(Name, Info);
+      DIGlobal Global = Info->symbolizeData(ModuleOffset);
+      return printDIGlobal(Global, Info);
     }
   }
-  std::stringstream ss;
-  ss << Name << "\n" << Start << " " << Size << "\n";
-  return ss.str();
+  return printDIGlobal(DIGlobal(), nullptr);
 }
 
 void LLVMSymbolizer::flush() {
@@ -359,9 +358,6 @@ LLVMSymbolizer::getOrCreateModuleInfo(const std::string &ModuleName) {
 std::string
 LLVMSymbolizer::printDILineInfo(DILineInfo LineInfo,
                                 const SymbolizableModule *ModInfo) const {
-  // By default, DILineInfo contains "<invalid>" for function/filename it
-  // cannot fetch. We replace it to "??" to make our output closer to addr2line.
-  static const std::string kDILineInfoBadString = "<invalid>";
   std::stringstream Result;
   if (Opts.PrintFunctions != FunctionNameKind::None) {
     std::string FunctionName = LineInfo.FunctionName;
@@ -378,6 +374,20 @@ LLVMSymbolizer::printDILineInfo(DILineInfo LineInfo,
   return Result.str();
 }
 
+std::string
+LLVMSymbolizer::printDIGlobal(DIGlobal Global,
+                              const SymbolizableModule *ModInfo) const {
+  std::stringstream Result;
+  std::string Name = Global.Name;
+  if (Name == kDILineInfoBadString)
+    Name = kBadString;
+  else if (Opts.Demangle)
+    Name = DemangleName(Name, ModInfo);
+  Result << Name << "\n";
+  Result << Global.Start << " " << Global.Size << "\n";
+  return Result.str();
+}
+
 // Undo these various manglings for Win32 extern "C" functions:
 // cdecl       - _foo
 // stdcall     - _foo@12
@@ -442,7 +452,7 @@ std::string LLVMSymbolizer::DemangleName(const std::string &Name,
     return (result == 0) ? Name : std::string(DemangledName);
   }
 #endif
-  if (ModInfo->isWin32Module())
+  if (ModInfo && ModInfo->isWin32Module())
     return std::string(demanglePE32ExternCFunc(Name));
   return Name;
 }