[DWARF] Centralize user_id <-> DWARFDIE conversions

[labath]

Summary

The logic for translating a user_id into a DWARFDIE was replicated in
several places. This removes that redundancy and settles on a single
implementation in SymbolFileDWARF.

The reason for choosing that instead of DIERef was that we were
always immediately converting the returned DIERef into a DWARFDIE
anyway, which meant that one had to specify the SymbolFileDWARF argument
twice (once to get the DIERef, and once to get the actual DIE). Also,
passing a higher-level object (SymbolFileDWARF) into a lower-level one
(DIERef) seemed like a less intuitive arrangement than doing things the
other way around.

[clayborg]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

137 ↗

(On Diff #198510)

Maybe just overload?:

DWARFDIE GetDIE(lldb::user_id_t uid);

138–139 ↗

(On Diff #198510)

Maybe just overload these?:

lldb::user_id_t GetUID(DWARFBaseDIE die);
lldb::user_id_t GetUID(DIERef ref);

[JDevlieghere]

Greg's suggestion for an overload seems reasonable. Otherwise LGTM.

[labath]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

138–139 ↗

(On Diff #198510)

Sounds good.

lldb/trunk/source/Plugins/SymbolFile/DWARF/DIERef.h

 class DWARFFormValue;
 class SymbolFileDWARF;
 
 struct DIERef {
   DIERef() = default;
 
   DIERef(dw_offset_t c, dw_offset_t d) : cu_offset(c), die_offset(d) {}
 
-  // In order to properly decode a lldb::user_id_t back into a DIERef we
-  // need the DWARF file since it knows if DWARF in .o files is being used
-  // (MacOSX) or if DWO files are being used. The encoding of the user ID
-  // differs between the two types of DWARF.
-  explicit DIERef(lldb::user_id_t uid, SymbolFileDWARF *dwarf);
-
   explicit DIERef(const DWARFFormValue &form_value);
 
-  // In order to properly encode a DIERef unto a lldb::user_id_t we need
-  // the DWARF file since it knows if DWARF in .o files is being used
-  // (MacOSX) or if DWO files are being used. The encoding of the user ID
-  // differs between the two types of DWARF.
-  lldb::user_id_t GetUID(SymbolFileDWARF *dwarf) const;
-
   bool operator<(const DIERef &ref) const {
     return die_offset < ref.die_offset;
   }
 
   bool operator<(const DIERef &ref) { return die_offset < ref.die_offset; }
 
   explicit operator bool() const {
     return cu_offset != DW_INVALID_OFFSET || die_offset != DW_INVALID_OFFSET;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DIERef.cpp

 //===-- DIERef.cpp ----------------------------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "DIERef.h"
 #include "DWARFUnit.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFFormValue.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 
-DIERef::DIERef(lldb::user_id_t uid, SymbolFileDWARF *dwarf)
-    : cu_offset(DW_INVALID_OFFSET), die_offset(uid & 0xffffffff) {
-  SymbolFileDWARFDebugMap *debug_map = dwarf->GetDebugMapSymfile();
-  if (debug_map) {
-    const uint32_t oso_idx = debug_map->GetOSOIndexFromUserID(uid);
-    SymbolFileDWARF *actual_dwarf = debug_map->GetSymbolFileByOSOIndex(oso_idx);
-    if (actual_dwarf) {
-      DWARFDebugInfo *debug_info = actual_dwarf->DebugInfo();
-      if (debug_info) {
-        DWARFUnit *dwarf_cu =
-            debug_info->GetCompileUnitContainingDIEOffset(die_offset);
-        if (dwarf_cu) {
-          cu_offset = dwarf_cu->GetOffset();
-          return;
-        }
-      }
-    }
-    die_offset = DW_INVALID_OFFSET;
-  } else {
-    cu_offset = uid >> 32;
-  }
-}
-
 DIERef::DIERef(const DWARFFormValue &form_value)
     : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {
   if (form_value.IsValid()) {
     const DWARFUnit *dwarf_cu = form_value.GetCompileUnit();
     if (dwarf_cu) {
       if (dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
         cu_offset = dwarf_cu->GetBaseObjOffset();
       else
         cu_offset = dwarf_cu->GetOffset();
     }
     die_offset = form_value.Reference();
   }
 }
-
-lldb::user_id_t DIERef::GetUID(SymbolFileDWARF *dwarf) const {
-  // Each SymbolFileDWARF will set its ID to what is expected.
-  //
-  // SymbolFileDWARF, when used for DWARF with .o files on MacOSX, has the
-  // ID set to the compile unit index.
-  //
-  // SymbolFileDWARFDwo sets the ID to the compile unit offset.
-  if (dwarf && die_offset != DW_INVALID_OFFSET)
-    return dwarf->GetID() | die_offset;
-  else
-    return LLDB_INVALID_UID;
-}

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

if (type_ptr == NULL) {
                 }
               }
             }
           }
         }
 
         type_sp = std::make_shared<Type>(
             die.GetID(), dwarf, type_name_const_str, byte_size, nullptr,
-            DIERef(encoding_uid).GetUID(dwarf), encoding_data_type, &decl,
+            dwarf->GetUID(DIERef(encoding_uid)), encoding_data_type, &decl,
             clang_type, resolve_state);
 
         dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
       } break;
 
       case DW_TAG_structure_type:
       case DW_TAG_union_type:
       case DW_TAG_class_type: {
if (type_ptr == NULL) {
                   static_cast<void *>(this), die.GetOffset(),
                   DW_TAG_value_to_name(tag), type_name_cstr, type_sp->GetID());
             }
 
             // We found a real definition for this type elsewhere so lets use
             // it and cache the fact that we found a complete type for this die
             dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
             clang::DeclContext *defn_decl_ctx = GetCachedClangDeclContextForDIE(
-                dwarf->DebugInfo()->GetDIE(DIERef(type_sp->GetID(), dwarf)));
+                dwarf->GetDIE(type_sp->GetID()));
             if (defn_decl_ctx)
               LinkDeclContextToDIE(defn_decl_ctx, die);
             return type_sp;
           }
         }
         assert(tag_decl_kind != -1);
         bool clang_type_was_created = false;
         clang_type.SetCompilerType(
if (type_ptr == NULL) {
                     type_sp->GetID());
               }
 
               // We found a real definition for this type elsewhere so lets use
               // it and cache the fact that we found a complete type for this
               // die
               dwarf->GetDIEToType()[die.GetDIE()] = type_sp.get();
               clang::DeclContext *defn_decl_ctx =
-                  GetCachedClangDeclContextForDIE(dwarf->DebugInfo()->GetDIE(
-                      DIERef(type_sp->GetID(), dwarf)));
+                  GetCachedClangDeclContextForDIE(
+                      dwarf->GetDIE(type_sp->GetID()));
               if (defn_decl_ctx)
                 LinkDeclContextToDIE(defn_decl_ctx, die);
               return type_sp;
             }
           }
           DEBUG_PRINTF("0x%8.8" PRIx64 ": %s (\"%s\")\n", die.GetID(),
                        DW_TAG_value_to_name(tag), type_name_cstr);
 
if (type_ptr == NULL) {
                 m_ast.GetEnumerationIntegerType(clang_type.GetOpaqueQualType());
           }
 
           LinkDeclContextToDIE(
               ClangASTContext::GetDeclContextForType(clang_type), die);
 
           type_sp = std::make_shared<Type>(
               die.GetID(), dwarf, type_name_const_str, byte_size, nullptr,
-              DIERef(encoding_form).GetUID(dwarf), Type::eEncodingIsUID, &decl,
+              dwarf->GetUID(DIERef(encoding_form)), Type::eEncodingIsUID, &decl,
               clang_type, Type::eResolveStateForward);
 
           if (ClangASTContext::StartTagDeclarationDefinition(clang_type)) {
             if (die.HasChildren()) {
               SymbolContext cu_sc(die.GetLLDBCompileUnit());
               bool is_signed = false;
               enumerator_clang_type.IsIntegerType(is_signed);
               ParseChildEnumerators(cu_sc, clang_type, is_signed,

                 bool alternate_defn = false;
                 if (class_type->GetID() != decl_ctx_die.GetID() ||
                     decl_ctx_die.GetContainingDWOModuleDIE()) {
                   alternate_defn = true;
 
                   // We uniqued the parent class of this function to another
                   // class so we now need to associate all dies under
                   // "decl_ctx_die" to DIEs in the DIE for "class_type"...
-                  SymbolFileDWARF *class_symfile = NULL;
-                  DWARFDIE class_type_die;
+                  DWARFDIE class_type_die = dwarf->GetDIE(class_type->GetID());
 
-                  SymbolFileDWARFDebugMap *debug_map_symfile =
-                      dwarf->GetDebugMapSymfile();
-                  if (debug_map_symfile) {
-                    class_symfile = debug_map_symfile->GetSymbolFileByOSOIndex(
-                        SymbolFileDWARFDebugMap::GetOSOIndexFromUserID(
-                            class_type->GetID()));
-                    class_type_die = class_symfile->DebugInfo()->GetDIE(
-                        DIERef(class_type->GetID(), dwarf));
-                  } else {
-                    class_symfile = dwarf;
-                    class_type_die = dwarf->DebugInfo()->GetDIE(
-                        DIERef(class_type->GetID(), dwarf));
-                  }
                   if (class_type_die) {
                     std::vector<DWARFDIE> failures;
 
                     CopyUniqueClassMethodTypes(decl_ctx_die, class_type_die,
                                                class_type, failures);
 
                     // FIXME do something with these failures that's smarter
                     // than

               }
             } else {
               clang_type =
                   m_ast.CreateArrayType(array_element_type, 0, is_vector);
             }
             ConstString empty_name;
             type_sp = std::make_shared<Type>(
                 die.GetID(), dwarf, empty_name, array_element_bit_stride / 8,
-                nullptr, DIERef(type_die_form).GetUID(dwarf),
+                nullptr, dwarf->GetUID(DIERef(type_die_form)),
                 Type::eEncodingIsUID, &decl, clang_type,
                 Type::eResolveStateFull);
             type_sp->SetEncodingType(element_type);
             m_ast.SetMetadataAsUserID(clang_type.GetOpaqueQualType(),
                                       die.GetID());
           }
         }
       } break;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

uint64_t DWARFBaseDIE::GetAttributeValueAsAddress(const dw_attr_t attr,
   if (IsValid())
     return m_die->GetAttributeValueAsAddress(GetDWARF(), GetCU(), attr,
                                              fail_value);
   else
     return fail_value;
 }
 
 lldb::user_id_t DWARFBaseDIE::GetID() const {
-  return GetDIERef().GetUID(GetDWARF());
+  if (IsValid())
+    return GetDWARF()->GetUID(*this);
+  return LLDB_INVALID_UID;
 }
 
 const char *DWARFBaseDIE::GetName() const {
   if (IsValid())
     return m_die->GetName(GetDWARF(), m_cu);
   else
     return nullptr;
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

llvm::Optional<ArrayInfo> GetDynamicArrayInfoForUID(
       const lldb_private::ExecutionContext *exe_ctx) override;
 
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
 
   lldb_private::Type *ResolveType(const DWARFDIE &die,
                                   bool assert_not_being_parsed = true,
                                   bool resolve_function_context = false);
 
-  SymbolFileDWARF *GetDWARFForUID(lldb::user_id_t uid);
-
-  DWARFDIE
-  GetDIEFromUID(lldb::user_id_t uid);
-
   lldb_private::CompilerDecl GetDeclForUID(lldb::user_id_t uid) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextForUID(lldb::user_id_t uid) override;
 
   lldb_private::CompilerDeclContext
   GetDeclContextContainingUID(lldb::user_id_t uid) override;
 
public:
 
   /// Return the list of Clang modules imported by this SymbolFile.
   const ExternalTypeModuleMap& getExternalTypeModules() const {
       return m_external_type_modules;
   }
 
   virtual DWARFDIE GetDIE(const DIERef &die_ref);
 
+  DWARFDIE GetDIE(lldb::user_id_t uid);
+
+  lldb::user_id_t GetUID(const DWARFBaseDIE &die) {
+    return GetID() | die.GetOffset();
+  }
+
+  lldb::user_id_t GetUID(const DIERef &ref) { return GetID() | ref.die_offset; }
+
   virtual std::unique_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die);
 
   // For regular SymbolFileDWARF instances the method returns nullptr,
   // for the instances of the subclass SymbolFileDWARFDwo
   // the method returns a pointer to the base compile unit.
   virtual DWARFUnit *GetBaseCompileUnit();
protected:
   virtual DIEToClangType &GetForwardDeclDieToClangType() {
     return m_forward_decl_die_to_clang_type;
   }
 
   virtual ClangTypeToDIE &GetForwardDeclClangTypeToDie() {
     return m_forward_decl_clang_type_to_die;
   }
 
+  struct DecodedUID {
+    SymbolFileDWARF *dwarf;
+    DIERef ref;
+  };
+  DecodedUID DecodeUID(lldb::user_id_t uid);
+
   SymbolFileDWARFDwp *GetDwpSymbolFile();
 
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;
 
   llvm::once_flag m_dwp_symfile_once_flag;
   std::unique_ptr<SymbolFileDWARFDwp> m_dwp_symfile;
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

std::vector<DWARFDIE> decl_ctx_die_list =
       ast_parser->GetDIEForDeclContext(decl_ctx);
 
   for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
     for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl;
          decl = decl.GetSibling())
       ast_parser->GetDeclForUIDFromDWARF(decl);
 }
 
-SymbolFileDWARF *SymbolFileDWARF::GetDWARFForUID(lldb::user_id_t uid) {
+SymbolFileDWARF::DecodedUID SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
   // must make sure we use the correct DWARF file when resolving things. On
   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
   // SymbolFileDWARF classes, one for each .o file. We can often end up with
   // references to other DWARF objects and we must be ready to receive a
   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
   // instance.
-  SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile();
-  if (debug_map)
-    return debug_map->GetSymbolFileByOSOIndex(
+  if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
+    SymbolFileDWARF *dwarf = debug_map->GetSymbolFileByOSOIndex(
         debug_map->GetOSOIndexFromUserID(uid));
-  return this;
+    return {dwarf, {DW_INVALID_OFFSET, dw_offset_t(uid)}};
+  }
+  return {this, {dw_offset_t(uid >> 32), dw_offset_t(uid)}};
 }
 
 DWARFDIE
-SymbolFileDWARF::GetDIEFromUID(lldb::user_id_t uid) {
+SymbolFileDWARF::GetDIE(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
-  // must make sure we use the correct DWARF file when resolving things. On
-  // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
-  // SymbolFileDWARF classes, one for each .o file. We can often end up with
-  // references to other DWARF objects and we must be ready to receive a
-  // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
-  // instance.
-  SymbolFileDWARF *dwarf = GetDWARFForUID(uid);
-  if (dwarf)
-    return dwarf->GetDIE(DIERef(uid, dwarf));
+
+  DecodedUID decoded = DecodeUID(uid);
+
+  if (decoded.dwarf)
+    return decoded.dwarf->GetDIE(decoded.ref);
+
   return DWARFDIE();
 }
 
 CompilerDecl SymbolFileDWARF::GetDeclForUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
-  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
-  // SymbolFileDWARF::GetDIEFromUID() for details.
-  DWARFDIE die = GetDIEFromUID(type_uid);
-  if (die)
+  // SymbolFileDWARF::GetDIE(). See comments inside the
+  // SymbolFileDWARF::GetDIE() for details.
+  if (DWARFDIE die = GetDIE(type_uid))
     return die.GetDecl();
   return CompilerDecl();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextForUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
-  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
-  // SymbolFileDWARF::GetDIEFromUID() for details.
-  DWARFDIE die = GetDIEFromUID(type_uid);
-  if (die)
+  // SymbolFileDWARF::GetDIE(). See comments inside the
+  // SymbolFileDWARF::GetDIE() for details.
+  if (DWARFDIE die = GetDIE(type_uid))
     return die.GetDeclContext();
   return CompilerDeclContext();
 }
 
 CompilerDeclContext
 SymbolFileDWARF::GetDeclContextContainingUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
-  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
-  // SymbolFileDWARF::GetDIEFromUID() for details.
-  DWARFDIE die = GetDIEFromUID(type_uid);
-  if (die)
+  // SymbolFileDWARF::GetDIE(). See comments inside the
+  // SymbolFileDWARF::GetDIE() for details.
+  if (DWARFDIE die = GetDIE(type_uid))
     return die.GetContainingDeclContext();
   return CompilerDeclContext();
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(lldb::user_id_t type_uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   // Anytime we have a lldb::user_id_t, we must get the DIE by calling
-  // SymbolFileDWARF::GetDIEFromUID(). See comments inside the
-  // SymbolFileDWARF::GetDIEFromUID() for details.
-  DWARFDIE type_die = GetDIEFromUID(type_uid);
-  if (type_die)
+  // SymbolFileDWARF::GetDIE(). See comments inside the
+  // SymbolFileDWARF::GetDIE() for details.
+  if (DWARFDIE type_die = GetDIE(type_uid))
     return type_die.ResolveType();
   else
     return nullptr;
 }
 
 llvm::Optional<SymbolFile::ArrayInfo>
 SymbolFileDWARF::GetDynamicArrayInfoForUID(
     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  DWARFDIE type_die = GetDIEFromUID(type_uid);
-  if (type_die)
+  if (DWARFDIE type_die = GetDIE(type_uid))
     return DWARFASTParser::ParseChildArrayInfo(type_die, exe_ctx);
   else
     return llvm::None;
 }
 
 Type *SymbolFileDWARF::ResolveTypeUID(const DIERef &die_ref) {
   return ResolveType(GetDIE(die_ref), true);
 }

 size_t SymbolFileDWARF::ParseVariablesForContext(const SymbolContext &sc) {
   ASSERT_MODULE_LOCK(this);
   if (sc.comp_unit != NULL) {
     DWARFDebugInfo *info = DebugInfo();
     if (info == NULL)
       return 0;
 
     if (sc.function) {
-      DWARFDIE function_die = info->GetDIE(DIERef(sc.function->GetID(), this));
+      DWARFDIE function_die = GetDIE(sc.function->GetID());
 
       const dw_addr_t func_lo_pc = function_die.GetAttributeValueAsAddress(
           DW_AT_low_pc, LLDB_INVALID_ADDRESS);
       if (func_lo_pc != LLDB_INVALID_ADDRESS) {
         const size_t num_variables = ParseVariables(
             sc, function_die.GetFirstChild(), func_lo_pc, true, true);
 
         // Let all blocks know they have parse all their variables
if (num_attributes > 0) {
         default:
           symbol_context_scope = sc.comp_unit;
           break;
         }
       }
 
       if (symbol_context_scope) {
         SymbolFileTypeSP type_sp(
-            new SymbolFileType(*this, DIERef(type_die_form).GetUID(this)));
+            new SymbolFileType(*this, GetUID(DIERef(type_die_form))));
 
         if (const_value.Form() && type_sp && type_sp->GetType())
           location.CopyOpcodeData(
               const_value.Unsigned(),
               type_sp->GetType()->GetByteSize().getValueOr(0),
               die.GetCU()->GetAddressByteSize());
 
         var_sp = std::make_shared<Variable>(
if (var_sp) {
                   sc_parent_die.GetID());
               if (block == NULL) {
                 // This must be a specification or abstract origin with a
                 // concrete block counterpart in the current function. We need
                 // to find the concrete block so we can correctly add the
                 // variable to it
                 const DWARFDIE concrete_block_die =
                     FindBlockContainingSpecification(
-                        DIERef(sc.function->GetID(), this),
+                        GetDIE(sc.function->GetID()),
                         sc_parent_die.GetOffset());
                 if (concrete_block_die)
                   block = sc.function->GetBlock(true).FindBlockByID(
                       concrete_block_die.GetID());
               }
 
               if (block != NULL) {
                 const bool can_create = false;
LLDB_LOG(log, "CollectCallEdges: Found call origin: {0} (retn-PC: {1:x})",
              call_origin.GetPubname(), return_pc);
     call_edges.emplace_back(call_origin.GetMangledName(), return_pc);
   }
   return call_edges;
 }
 
 std::vector<lldb_private::CallEdge>
 SymbolFileDWARF::ParseCallEdgesInFunction(UserID func_id) {
-  DWARFDIE func_die = GetDIEFromUID(func_id.GetID());
+  DWARFDIE func_die = GetDIE(func_id.GetID());
   if (func_die.IsValid())
     return CollectCallEdges(func_die);
   return {};
 }
 
 // PluginInterface protocol
 ConstString SymbolFileDWARF::GetPluginName() { return GetPluginNameStatic(); }