WIP: [lldb][COFF] Enhance symtab loading of symbol and export tables

[alvinhochun]

Summary

This reimplements ObjectFilePECOFF::ParseSymtab with the following
changes:

• When the image has both an export table and a COFF symbol table, the symbols obtained from the symbol table no longer get erased.
• Remove manual data extraction in favour of using what COFFObjectFile provides.
• Mark symbols from the export table as "External" instead of "Debug".
• Support DLL forwarder exports (marked as re-exported).
• Handle absolute symbols in the symbol table.
• Heuristically set some symbol types. Symbols in the symbol table starting in __imp_ (dllimport IAT reference) or .refptr. (mingw stub) are marked as "Data", because their locations store a pointer address.
• When a symbol in the symbol table is a duplicate of an exported symbol, its info will be synchronized with the exported symbol, then it will be marked as "Additional" type to avoid unwanted repetition when used in commands like disassemble.

[mstorsjo]

So previously, LLDB essentially used the COFF symbol table for executables, but only the list of exported symbols for DLLs, ignoring (or, reading and then overwriting) the symbol table for any DLL with exports? Then this certainly does look like a good direction.

Overall, I think this does look nice, but it's certainly hard to rewrite and wrap one's head around. When you've settled what you want to achieve, can you try to split it up into a short series of patches, so that the initial rewrite patch doesn't add a ton of extra functionality, but only covers the rewrite and appending instead of wiping symbols?

lldb/source/Commands/CommandObjectTarget.cpp

1558

Looks like this is a stray change unrelated to the rest (although it does seem correct).

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

787

If we mean to append to the symbol table here, shouldn't we start with i = symtab.size() or similar? Otherwise we'd start overwriting the existing symbols from the start of the table?

819

What about the case when a symbol is exported with a different name than the local symbol? (This is doable with def files e.g. as ExportedName = LocalName iirc.) Is it worth to have a map of address -> exported symbol, to use instead of the raw name?

917

If it's relevant, we can look up what section the exported address is in, and check if the section is executable or not.

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

84

For ease of review (when removing the WIP status), I think it'd be easier to wrap the head around, if new features like these were deferred to a separate patch.

[alvinhochun]

Thanks for the review. Yes I shall split the changes into smaller pieces to aid review.

lldb/source/Commands/CommandObjectTarget.cpp

1558

Oh right, this is relevant for https://reviews.llvm.org/D131705#inline-1292343. I'll make sure not to mix in this change for the final patch.

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

787

I made symtab.Extend return a pointer to the first item of the appended range, so counting from 0 does not overwrite existing symbols.

819

Indeed it is a good idea to match symbols with different export names to synchronize the symbol types. I probably should use a vector<pair<address, export_name>> sorted by address for lookup instead.

917

Right, this is something we can do too.

[mstorsjo]

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

787

Ah, I see - ok, good then, otherwise I was wondering how this was working at all :-)

819

Is it even relevant to keep the name in the vector in that case? As you'd only be looking up on address anyway, and based on that you can get the symbol name from the pointed-at symbol anyway, right?

[alvinhochun]

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

819

Ah, I guess I meant to say the symbol index there...

[alvinhochun]

Separated the first part with some new changes here: https://reviews.llvm.org/D134196

[alvinhochun]

Handled in separate changes.

lldb/include/lldb/Symbol/Symtab.h

public:
   enum Visibility { eVisibilityAny, eVisibilityExtern, eVisibilityPrivate };
 
   Symtab(ObjectFile *objfile);
   ~Symtab();
 
   void PreloadSymbols();
   void Reserve(size_t count);
   Symbol *Resize(size_t count);
+  Symbol *Extend(size_t count);
   uint32_t AddSymbol(const Symbol &symbol);
   size_t GetNumSymbols() const;
   void SectionFileAddressesChanged();
   void
   Dump(Stream *s, Target *target, SortOrder sort_type,
        Mangled::NamePreference name_preference = Mangled::ePreferDemangled);
   void Dump(Stream *s, Target *target, std::vector<uint32_t> &indexes,
             Mangled::NamePreference name_preference =
                 Mangled::ePreferDemangled) const;
   uint32_t GetIndexForSymbol(const Symbol *symbol) const;
   std::recursive_mutex &GetMutex() { return m_mutex; }
   Symbol *FindSymbolByID(lldb::user_id_t uid) const;
   Symbol *SymbolAtIndex(size_t idx);
   const Symbol *SymbolAtIndex(size_t idx) const;
   Symbol *FindSymbolWithType(lldb::SymbolType symbol_type,
                              Debug symbol_debug_type,
                              Visibility symbol_visibility, uint32_t &start_idx);
+  bool HasSymbolWithType(lldb::SymbolType symbol_type, Debug symbol_debug_type,
+                         Visibility symbol_visibility) const;
   /// Get the parent symbol for the given symbol.
   ///
   /// Many symbols in symbol tables are scoped by other symbols that
   /// contain one or more symbol. This function will look for such a
   /// containing symbol and return it if there is one.
   const Symbol *GetParent(Symbol *symbol) const;
   uint32_t AppendSymbolIndexesWithType(lldb::SymbolType symbol_type,
                                        std::vector<uint32_t> &indexes,

lldb/source/Commands/CommandObjectTarget.cpp

for (uint32_t i = 0; i < num_matches; ++i) {
         } else {
           strm.IndentMore();
           strm.Indent("    Value: ");
           strm.Printf("0x%16.16" PRIx64 "\n", symbol->GetRawValue());
           if (symbol->GetByteSizeIsValid()) {
             strm.Indent("    Size: ");
             strm.Printf("0x%16.16" PRIx64 "\n", symbol->GetByteSize());
           }
+          strm.IndentLess();
         }
       }
     }
     strm.IndentLess();
   }
   return num_matches;
 }
 

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.h

typedef struct coff_opt_header {
     uint64_t heap_reserve_size = 0;
     uint64_t heap_commit_size = 0;
     uint32_t loader_flags = 0;
     //    uint32_t  num_data_dir_entries;
     std::vector<data_directory>
         data_dirs; // will contain num_data_dir_entries entries
   } coff_opt_header_t;
 
-  enum coff_data_dir_type {
-    coff_data_dir_export_table = 0,
-    coff_data_dir_import_table = 1,
-    coff_data_dir_exception_table = 3
-  };
-
   typedef struct section_header {
     char name[8] = {};
     uint32_t vmsize = 0;  // Virtual Size
     uint32_t vmaddr = 0;  // Virtual Addr
     uint32_t size = 0;    // File size
     uint32_t offset = 0;  // File offset
     uint32_t reloff = 0;  // Offset to relocations
     uint32_t lineoff = 0; // Offset to line table entries
     uint16_t nreloc = 0;  // Number of relocation entries
     uint16_t nline = 0;   // Number of line table entries
     uint32_t flags = 0;
   } section_header_t;
 
-  typedef struct coff_symbol {
-    char name[8] = {};
-    uint32_t value = 0;
-    uint16_t sect = 0;
-    uint16_t type = 0;
-    uint8_t storage = 0;
-    uint8_t naux = 0;
-  } coff_symbol_t;
-
-  typedef struct export_directory_entry {
-    uint32_t characteristics = 0;
-    uint32_t time_date_stamp = 0;
-    uint16_t major_version = 0;
-    uint16_t minor_version = 0;
-    uint32_t name = 0;
-    uint32_t base = 0;
-    uint32_t number_of_functions = 0;
-    uint32_t number_of_names = 0;
-    uint32_t address_of_functions = 0;
-    uint32_t address_of_names = 0;
-    uint32_t address_of_name_ordinals = 0;
-  } export_directory_entry;
-
   static bool ParseDOSHeader(lldb_private::DataExtractor &data,
                              dos_header_t &dos_header);
   static bool ParseCOFFHeader(lldb_private::DataExtractor &data,
                               lldb::offset_t *offset_ptr,
                               coff_header_t &coff_header);
   bool ParseCOFFOptionalHeader(lldb::offset_t *offset_ptr);
   bool ParseSectionHeaders(uint32_t offset);
 
static lldb::SectionType GetSectionType(llvm::StringRef sect_name,
                                           const section_header_t &sect);
 
   typedef std::vector<section_header_t> SectionHeaderColl;
   typedef SectionHeaderColl::iterator SectionHeaderCollIter;
   typedef SectionHeaderColl::const_iterator SectionHeaderCollConstIter;
 
 private:
   bool CreateBinary();
+  void AppendFromCOFFSymbolTable(lldb_private::SectionList *sect_list,
+                                 const llvm::StringMap<uint32_t> &exported_syms,
+                                 lldb_private::Symtab &symtab);
+  void AppendFromExportTable(lldb_private::SectionList *sect_list,
+                             llvm::StringMap<uint32_t> &exported_syms,
+                             lldb_private::Symtab &symtab);
 
   dos_header_t m_dos_header;
   coff_header_t m_coff_header;
   coff_opt_header_t m_coff_header_opt;
   SectionHeaderColl m_sect_headers;
   lldb::addr_t m_image_base;
   lldb_private::Address m_entry_point_address;
   llvm::Optional<lldb_private::FileSpecList> m_deps_filespec;
   std::unique_ptr<llvm::object::COFFObjectFile> m_binary;
   lldb_private::UUID m_uuid;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_OBJECTFILE_PECOFF_OBJECTFILEPECOFF_H

lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp

 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
 #include "lldb/Utility/UUID.h"
-#include "llvm/BinaryFormat/COFF.h"
 
+#include "llvm/ADT/SmallString.h"
+#include "llvm/ADT/StringMap.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/BinaryFormat/COFF.h"
 #include "llvm/Object/COFFImportFile.h"
 #include "llvm/Support/CRC.h"
 #include "llvm/Support/Error.h"
+#include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 
+#include <cstdint>
+
 #define IMAGE_DOS_SIGNATURE 0x5A4D    // MZ
 #define IMAGE_NT_SIGNATURE 0x00004550 // PE00
 #define OPT_HEADER_MAGIC_PE32 0x010b
 #define OPT_HEADER_MAGIC_PE32_PLUS 0x020b
 
 using namespace lldb;
 using namespace lldb_private;
 
if (const char *name = m_data.GetCStr(&string_file_offset))
       return name;
     return "";
   }
   return hdr_name;
 }
 
 void ObjectFilePECOFF::ParseSymtab(Symtab &symtab) {
   SectionList *sect_list = GetSectionList();
-  const uint32_t num_syms = m_coff_header.nsyms;
-  if (m_file && num_syms > 0 && m_coff_header.symoff > 0) {
-    const uint32_t symbol_size = 18;
-    const size_t symbol_data_size = num_syms * symbol_size;
-    // Include the 4-byte string table size at the end of the symbols
-    DataExtractor symtab_data =
-        ReadImageData(m_coff_header.symoff, symbol_data_size + 4);
-    lldb::offset_t offset = symbol_data_size;
-    const uint32_t strtab_size = symtab_data.GetU32(&offset);
-    if (strtab_size > 0) {
-      DataExtractor strtab_data = ReadImageData(
-          m_coff_header.symoff + symbol_data_size, strtab_size);
-
-      offset = 0;
-      std::string symbol_name;
-      Symbol *symbols = symtab.Resize(num_syms);
-      for (uint32_t i = 0; i < num_syms; ++i) {
-        coff_symbol_t symbol;
-        const uint32_t symbol_offset = offset;
-        const char *symbol_name_cstr = nullptr;
-        // If the first 4 bytes of the symbol string are zero, then they
-        // are followed by a 4-byte string table offset. Else these
-        // 8 bytes contain the symbol name
-        if (symtab_data.GetU32(&offset) == 0) {
-          // Long string that doesn't fit into the symbol table name, so
-          // now we must read the 4 byte string table offset
-          uint32_t strtab_offset = symtab_data.GetU32(&offset);
-          symbol_name_cstr = strtab_data.PeekCStr(strtab_offset);
-          symbol_name.assign(symbol_name_cstr);
-        } else {
-          // Short string that fits into the symbol table name which is 8
-          // bytes
-          offset += sizeof(symbol.name) - 4; // Skip remaining
-          symbol_name_cstr = symtab_data.PeekCStr(symbol_offset);
-          if (symbol_name_cstr == nullptr)
-            break;
-          symbol_name.assign(symbol_name_cstr, sizeof(symbol.name));
-        }
-        symbol.value = symtab_data.GetU32(&offset);
-        symbol.sect = symtab_data.GetU16(&offset);
-        symbol.type = symtab_data.GetU16(&offset);
-        symbol.storage = symtab_data.GetU8(&offset);
-        symbol.naux = symtab_data.GetU8(&offset);
-        symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str()));
-        if ((int16_t)symbol.sect >= 1) {
-          Address symbol_addr(sect_list->FindSectionByID(symbol.sect),
-                              symbol.value);
-          symbols[i].GetAddressRef() = symbol_addr;
-          symbols[i].SetType(MapSymbolType(symbol.type));
-        }
+  llvm::StringMap<uint32_t> exported_syms;
+  AppendFromExportTable(sect_list, exported_syms, symtab);
+  AppendFromCOFFSymbolTable(sect_list, exported_syms, symtab);
+
+void ObjectFilePECOFF::AppendFromCOFFSymbolTable(
+    SectionList *sect_list, const llvm::StringMap<uint32_t> &exported_syms,
+    Symtab &symtab) {
+  Log *log = GetLog(LLDBLog::Object);
+  const uint32_t num_syms = m_binary->getNumberOfSymbols();
+  if (num_syms == 0)
+    return;
+  // Check that this is not a bigobj
+  if (m_binary->getSymbolTableEntrySize() !=
+      sizeof(llvm::object::coff_symbol16))
+    return;
+
+  Symbol *symbols = symtab.Extend(num_syms);
+  uint32_t i = 0;
+  for (const auto &sym_ref : m_binary->symbols()) {
+    const auto coff_sym_ref = m_binary->getCOFFSymbol(sym_ref);
+    auto name_or_error = sym_ref.getName();
+    if (auto err = name_or_error.takeError()) {
+      LLDB_LOG(log,
+               "ObjectFilePECOFF::AppendFromCOFFSymbolTable - failed to get "
+               "symbol table entry name: {0}",
+               llvm::fmt_consume(std::move(err)));
+      continue;
+    const llvm::StringRef sym_name = *name_or_error;
+    symbols[i].GetMangled().SetValue(ConstString(sym_name));
+    int16_t section_number =
+        static_cast<int16_t>(coff_sym_ref.getSectionNumber());
+    if (section_number >= 1) {
+      symbols[i].GetAddressRef() = Address(
+          sect_list->FindSectionByID(section_number), coff_sym_ref.getValue());
+      symbols[i].SetType(MapSymbolType(coff_sym_ref.getType()));
+      if (symbols[i].GetType() == lldb::eSymbolTypeInvalid)
+        if (sym_name.startswith("__imp_") || sym_name.startswith(".refptr."))
+          symbols[i].SetType(lldb::eSymbolTypeData);
+    } else if (section_number == -1) {
+      symbols[i].GetAddressRef() = Address(coff_sym_ref.getValue());
+      symbols[i].SetType(lldb::eSymbolTypeAbsolute);
+    }
+
+    // Handle duplicate of an exported symbol
+    const auto exported_it = exported_syms.find(sym_name);
+    if (exported_it != exported_syms.end()) {
+      Symbol *exported = symtab.SymbolAtIndex(exported_it->getValue());
+      if (exported->GetType() != lldb::eSymbolTypeReExported &&
+          exported->GetAddressRef() == symbols[i].GetAddressRef()) {
+        symbols[i].SetID(exported->GetID());
+        symbols[i].SetExternal(true);
+        // Previously we assumed an exported symbol is always code, now we
+        // fix it up if otherwise.
+        if (symbols[i].GetType() == lldb::eSymbolTypeInvalid)
+          symbols[i].SetType(lldb::eSymbolTypeData);
+        exported->SetType(symbols[i].GetType());
+        // We don't want the symbol to be duplicated (e.g. when running
+        // `disas -n func`), but we also want to keep this entry, so we mark it
+        // as additional.
+        symbols[i].SetType(lldb::eSymbolTypeAdditional);
+      }
+    }
+    i++;
+  }
+  // Trim excess entries if we skipped any.
+  if (i < num_syms)
+    symtab.Resize(symtab.GetIndexForSymbol(&symbols[i]));
+}
+
+void ObjectFilePECOFF::AppendFromExportTable(
+    SectionList *sect_list, llvm::StringMap<uint32_t> &exported_syms,
+    Symtab &symtab) {
+  Log *log = GetLog(LLDBLog::Object);
+  const auto *export_table = m_binary->getExportTable();
+  if (!export_table)
+    return;
+  const uint32_t num_syms = export_table->AddressTableEntries;
+  if (num_syms == 0)
+    return;
 
-        if (symbol.naux > 0) {
-          i += symbol.naux;
-          offset += symbol.naux * symbol_size;
-        }
+  Symbol *symbols = symtab.Extend(num_syms);
+  uint32_t i = 0;
+  // Read each export table entry, ordered by ordinal instead of by name.
+  for (const auto &entry : m_binary->export_directories()) {
+    llvm::StringRef sym_name;
+    if (auto err = entry.getSymbolName(sym_name)) {
+      LLDB_LOG(log,
+               "ObjectFilePECOFF::AppendFromExportTable - failed to get export "
+               "table entry name: {0}",
+               llvm::fmt_consume(std::move(err)));
+      continue;
+    // Note: symbol name may be empty if it is only exported by ordinal.
+    symbols[i].GetMangled().SetValue(ConstString(sym_name));
+
+    uint32_t ordinal;
+    llvm::cantFail(entry.getOrdinal(ordinal));
+    symbols[i].SetID(ordinal);
+
+    bool is_forwarder;
+    llvm::cantFail(entry.isForwarder(is_forwarder));
+    if (is_forwarder) {
+      // Forwarded export symbol name in the form of `DLLNAME.funcname` or
+      // `DLLNAME.#42`.
+      llvm::StringRef forwarder_name;
+      if (auto err = entry.getForwardTo(forwarder_name)) {
+        LLDB_LOG(log,
+                 "ObjectFilePECOFF::AppendFromExportTable - failed to get "
+                 "forwarder name of forwarder export '{0}': {1}",
+                 sym_name, llvm::fmt_consume(std::move(err)));
+        continue;
       }
+      size_t dot_pos = forwarder_name.find_first_of('.');
+      if (dot_pos == llvm::StringRef::npos) {
+        LLDB_LOG(log,
+                 "ObjectFilePECOFF::AppendFromExportTable - forwarder export "
+                 "'{0}' has invalid forwarder name '{1}'",
+                 sym_name, forwarder_name);
+        symbols[i].SetType(lldb::eSymbolTypeInvalid);
+      } else {
+        llvm::StringRef reexport_name = forwarder_name.drop_front(dot_pos + 1);
+        // FIXME: How to handle forwarded ordinal number starting with `#`?
+        symbols[i].SetReExportedSymbolName(ConstString(reexport_name));
+
+        llvm::SmallString<128> dll_name{forwarder_name.take_front(dot_pos),
+                                        ".dll"};
+        FileSpec dll_spec(dll_name, FileSpec::Style::windows);
+        size_t index = m_deps_filespec->FindFileIndex(0, dll_spec, false);
+        if (index != UINT32_MAX)
+          symbols[i].SetReExportedSymbolSharedLibrary(
+              m_deps_filespec->GetFileSpecAtIndex(index));
       }
+    } else {
+      uint32_t function_rva;
+      if (auto err = entry.getExportRVA(function_rva)) {
+        LLDB_LOG(log,
+                 "ObjectFilePECOFF::AppendFromExportTable - failed to get "
+                 "address of export entry '{0}': {1}",
+                 sym_name, llvm::fmt_consume(std::move(err)));
+        continue;
       }
-
-  // Read export header
-  if (coff_data_dir_export_table < m_coff_header_opt.data_dirs.size() &&
-      m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmsize > 0 &&
-      m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr > 0) {
-    export_directory_entry export_table;
-    uint32_t data_start =
-        m_coff_header_opt.data_dirs[coff_data_dir_export_table].vmaddr;
-
-    DataExtractor symtab_data = ReadImageDataByRVA(
-        data_start, m_coff_header_opt.data_dirs[0].vmsize);
-    lldb::offset_t offset = 0;
-
-    // Read export_table header
-    export_table.characteristics = symtab_data.GetU32(&offset);
-    export_table.time_date_stamp = symtab_data.GetU32(&offset);
-    export_table.major_version = symtab_data.GetU16(&offset);
-    export_table.minor_version = symtab_data.GetU16(&offset);
-    export_table.name = symtab_data.GetU32(&offset);
-    export_table.base = symtab_data.GetU32(&offset);
-    export_table.number_of_functions = symtab_data.GetU32(&offset);
-    export_table.number_of_names = symtab_data.GetU32(&offset);
-    export_table.address_of_functions = symtab_data.GetU32(&offset);
-    export_table.address_of_names = symtab_data.GetU32(&offset);
-    export_table.address_of_name_ordinals = symtab_data.GetU32(&offset);
-
-    bool has_ordinal = export_table.address_of_name_ordinals != 0;
-
-    lldb::offset_t name_offset = export_table.address_of_names - data_start;
-    lldb::offset_t name_ordinal_offset =
-        export_table.address_of_name_ordinals - data_start;
-
-    Symbol *symbols = symtab.Resize(export_table.number_of_names);
-
-    std::string symbol_name;
-
-    // Read each export table entry
-    for (size_t i = 0; i < export_table.number_of_names; ++i) {
-      uint32_t name_ordinal =
-          has_ordinal ? symtab_data.GetU16(&name_ordinal_offset) : i;
-      uint32_t name_address = symtab_data.GetU32(&name_offset);
-
-      const char *symbol_name_cstr =
-          symtab_data.PeekCStr(name_address - data_start);
-      symbol_name.assign(symbol_name_cstr);
-
-      lldb::offset_t function_offset = export_table.address_of_functions -
-                                        data_start +
-                                        sizeof(uint32_t) * name_ordinal;
-      uint32_t function_rva = symtab_data.GetU32(&function_offset);
-
       Address symbol_addr(m_coff_header_opt.image_base + function_rva,
                           sect_list);
-      symbols[i].GetMangled().SetValue(ConstString(symbol_name.c_str()));
       symbols[i].GetAddressRef() = symbol_addr;
+      // Treat the exported symbol as code for now. An exported symbol may
+      // actually be data, but this is relatively rare and we cannot tell
+      // from just the export table.
       symbols[i].SetType(lldb::eSymbolTypeCode);
-      symbols[i].SetDebug(true);
-    }
+      symbols[i].SetExternal(true);
     }
+    if (!sym_name.empty())
+      exported_syms[sym_name] = symtab.GetIndexForSymbol(&symbols[i]);
+    i++;
+  }
+  // Trim excess entries if we skipped any.
+  if (i < num_syms)
+    symtab.Resize(symtab.GetIndexForSymbol(&symbols[i]));
 }
 
 std::unique_ptr<CallFrameInfo> ObjectFilePECOFF::CreateCallFrameInfo() {
-  if (coff_data_dir_exception_table >= m_coff_header_opt.data_dirs.size())
+  if (llvm::COFF::EXCEPTION_TABLE >= m_coff_header_opt.data_dirs.size())
     return {};
 
   data_directory data_dir_exception =
-      m_coff_header_opt.data_dirs[coff_data_dir_exception_table];
+      m_coff_header_opt.data_dirs[llvm::COFF::EXCEPTION_TABLE];
   if (!data_dir_exception.vmaddr)
     return {};
 
   if (m_coff_header.machine != llvm::COFF::IMAGE_FILE_MACHINE_AMD64)
     return {};
 
   return std::make_unique<PECallFrameInfo>(*this, data_dir_exception.vmaddr,
                                            data_dir_exception.vmsize);
uint32_t ObjectFilePECOFF::ParseDependentModules() {
 
   Log *log = GetLog(LLDBLog::Object);
   LLDB_LOG(log, "this = {0}, module = {1} ({2}), file = {3}, binary = {4}",
            this, GetModule().get(), GetModule()->GetSpecificationDescription(),
            m_file.GetPath(), m_binary.get());
 
   m_deps_filespec = FileSpecList();
 
-  for (const auto &entry : m_binary->import_directories()) {
-    llvm::StringRef dll_name;
-    // Report a bogus entry.
-    if (llvm::Error e = entry.getName(dll_name)) {
-      LLDB_LOGF(log,
-                "ObjectFilePECOFF::ParseDependentModules() - failed to get "
-                "import directory entry name: %s",
-                llvm::toString(std::move(e)).c_str());
-      continue;
-    }
-
+  auto add_dll = [this](llvm::StringRef dll_name) {
     // At this moment we only have the base name of the DLL. The full path can
     // only be seen after the dynamic loading.  Our best guess is Try to get it
     // with the help of the object file's directory.
     llvm::SmallString<128> dll_fullpath;
     FileSpec dll_specs(dll_name);
     dll_specs.SetDirectory(m_file.GetDirectory());
 
     if (!llvm::sys::fs::real_path(dll_specs.GetPath(), dll_fullpath))
       m_deps_filespec->EmplaceBack(dll_fullpath);
     else {
       // Known DLLs or DLL not found in the object file directory.
       m_deps_filespec->EmplaceBack(dll_name);
     }
+  };
+
+  for (const auto &entry : m_binary->import_directories()) {
+    llvm::StringRef dll_name;
+    // Report a bogus entry.
+    if (llvm::Error e = entry.getName(dll_name)) {
+      LLDB_LOGF(log,
+                "ObjectFilePECOFF::ParseDependentModules() - failed to get "
+                "import directory entry name: %s",
+                llvm::toString(std::move(e)).c_str());
+      continue;
+    }
+    add_dll(dll_name);
   }
+
+  // Forwarder exports may reference DLLs not imported by self.
+  for (const auto &entry : m_binary->export_directories()) {
+    bool is_forwarder;
+    llvm::cantFail(entry.isForwarder(is_forwarder));
+    if (!is_forwarder)
+      continue;
+    llvm::StringRef forwarder_name;
+    if (auto err = entry.getForwardTo(forwarder_name)) {
+      llvm::consumeError(std::move(err));
+      continue;
+    }
+    size_t dot_pos = forwarder_name.find_first_of('.');
+    if (dot_pos == llvm::StringRef::npos)
+      continue;
+    llvm::SmallString<128> dll_name{forwarder_name.take_front(dot_pos), ".dll"};
+    FileSpec dll_spec(dll_name, FileSpec::Style::windows);
+    size_t index = m_deps_filespec->FindFileIndex(0, dll_spec, false);
+    if (index == UINT32_MAX)
+      add_dll(dll_name);
+  }
+
   return m_deps_filespec->GetSize();
 }
 
 uint32_t ObjectFilePECOFF::GetDependentModules(FileSpecList &files) {
   auto num_modules = ParseDependentModules();
   auto original_size = files.GetSize();
 
   for (unsigned i = 0; i < num_modules; ++i)

lldb/source/Plugins/SymbolFile/Symtab/SymbolFileSymtab.cpp

if (symtab) {
 
       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeCode, Symtab::eDebugNo,
                                               Symtab::eVisibilityAny,
                                               m_code_indexes)) {
         symtab->SortSymbolIndexesByValue(m_code_indexes, true);
         abilities |= Functions;
       }
 
+      if (symtab->HasSymbolWithType(eSymbolTypeReExported, Symtab::eDebugAny,
+                                    Symtab::eVisibilityAny)) {
+        abilities |= Functions;
+      }
+
       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeData,
                                               m_data_indexes)) {
         symtab->SortSymbolIndexesByValue(m_data_indexes, true);
         abilities |= GlobalVariables;
       }
 
       lldb_private::Symtab::IndexCollection objc_class_indexes;
       if (symtab->AppendSymbolIndexesWithType(eSymbolTypeObjCClass,

lldb/source/Symbol/Symtab.cpp

 
 Symbol *Symtab::Resize(size_t count) {
   // Clients should grab the mutex from this symbol table and lock it manually
   // when calling this function to avoid performance issues.
   m_symbols.resize(count);
   return m_symbols.empty() ? nullptr : &m_symbols[0];
 }
 
+Symbol *Symtab::Extend(size_t count) {
+  // Clients should grab the mutex from this symbol table and lock it manually
+  // when calling this function to avoid performance issues.
+  auto old_size = m_symbols.size();
+  m_symbols.resize(old_size + count);
+  return m_symbols.empty() ? nullptr : &m_symbols[old_size];
+}
+
 uint32_t Symtab::AddSymbol(const Symbol &symbol) {
   // Clients should grab the mutex from this symbol table and lock it manually
   // when calling this function to avoid performance issues.
   uint32_t symbol_idx = m_symbols.size();
   auto &name_to_index = GetNameToSymbolIndexMap(lldb::eFunctionNameTypeNone);
   name_to_index.Clear();
   m_file_addr_to_index.Clear();
   m_symbols.push_back(symbol);
if (symbol_type == eSymbolTypeAny ||
         start_idx = idx;
         return &m_symbols[idx];
       }
     }
   }
   return nullptr;
 }
 
+bool Symtab::HasSymbolWithType(SymbolType symbol_type, Debug symbol_debug_type,
+                               Visibility symbol_visibility) const {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+
+  const size_t count = m_symbols.size();
+  for (size_t idx = 0; idx < count; ++idx) {
+    if (symbol_type == eSymbolTypeAny ||
+        m_symbols[idx].GetType() == symbol_type) {
+      if (CheckSymbolAtIndex(idx, symbol_debug_type, symbol_visibility)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 void
 Symtab::FindAllSymbolsWithNameAndType(ConstString name,
                                       SymbolType symbol_type,
                                       std::vector<uint32_t> &symbol_indexes) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
   // Initialize all of the lookup by name indexes before converting NAME to a
   // uniqued string NAME_STR below.

llvm/include/llvm/Object/COFF.h

public:
   uint32_t getNumberOfSymbols() const {
     if (!SymbolTable16 && !SymbolTable32)
       return 0;
     return getRawNumberOfSymbols();
   }
 
   uint32_t getStringTableSize() const { return StringTableSize; }
 
+  const export_directory_table_entry *getExportTable() const {
+    return ExportDirectory;
+  }
+
   const coff_load_configuration32 *getLoadConfig32() const {
     assert(!is64());
     return reinterpret_cast<const coff_load_configuration32 *>(LoadConfig);
   }
 
   const coff_load_configuration64 *getLoadConfig64() const {
     assert(is64());
     return reinterpret_cast<const coff_load_configuration64 *>(LoadConfig);