[lldb][PDB] Add ObjectFile PDB plugin

[zequanwu]

Summary

To allow loading PDB file with target symbols add command.

[zequanwu]

How can I start lldb at specified path so that target symbols add bar.pdb could find the pdb path? (For testing)

[zequanwu]

• Add GetArchitecture method, similar to ObjectFilePECOFF
• Add a test case.

[zequanwu]

elaborate CHECK

[labath]

I think this is a good start. See inline comments for details. In addition to the test for the "target symbols add" flow it would be good to have a separate test for the ObjectFilePDB functionality. You can look at existing tests in test/Shell/ObjectFile for inspiration.

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

11

You should be able to delete this line too clang-format should know to put this file first.

46

There's also a third copy of this code in ProcessMinidump (MinidumpParser.cpp). I think it's time to factor this out somehow. We could either create a new file in the Utility module, or put this functionality in directly inside the UUID class -- I'm not currently sure what's better.

173

I'm pretty sure this check is bogus and can never be false.

177–198

Could this use the same algorithm as ObjectFilePDB::GetArchitecture ?

208–210

Leave this unimplemented. PDBs don't have sections and are not loaded into memory, so the function does not apply.

216–217

This shouldn't be necessary. What "normally" happens here is that an object file is adding own sections *into* the "unified" section list -- not the other way around. Since we're pretending that the pdb file has no sections (and that's kind of true) I think you should just return an empty section list here, and not touch the unified list at all.

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

145

revert spurious changes.

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

267–268

Instead of changing loadMatchingPDBFile I think we ought to change this to something like:

if (auto *pdb = llvm::dyn_cast<ObjectFilePDB>(m_objfile_sp)) {
  file_up = pdb->giveMeAPDBFile(); 
  // PS: giveMeAPDBFile is a new pdb-specific public method on ObjectFilePDB
  // PS: possibly this should not return a PDBFile, but a PDBIndex directly -- I don't know the details but the general idea is that it could/should reuse the pdb parsing state that the objectfile class has already created
} else 
  file_up = do_the_loadMatchingPDBFile_fallback();

The reason for that is that it avoids opening the pdb file twice (once in the object file and once here). Another reason is that I believe the entire loadMatchingPDBFile function should disappear. Finding the pdb file should not be the job of the symbol file class -- we have symbol vendors for that. However, we should keep the fallback for now to keep the patch small...

lldb/test/Shell/SymbolFile/NativePDB/load-pdb.cpp

15

I'd just pass commands to lldb directly via -o.

[zequanwu]

• address comments.
• add tests.
• move loadPDBFile from SymbolFileNativePDB.cpp to ObjectFilePDB.cpp and use it to create unique_ptr of PDBFile so that we can move it around.

[zequanwu]

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

177–198

No. This part is the same algorithm as the part in ObjectFilePECOFF::GetModuleSpecifications, https://github.com/llvm/llvm-project/blob/master/lldb/source/Plugins/ObjectFile/PECOFF/ObjectFilePECOFF.cpp#L194-L215.

The ObjectFilePDB::GetArchitecture is same as ObjectFilePECOFF::GetArchitecture.

208–210

This is actually necessary. It's called at SymbolFileNativePDB::InitializeObject. Otherwise, setting breakpoint won't work.

216–217

The reason why I copy section list from unified_section_list to m_sections_up is to let GetBaseAddress be able to return the right base address.

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

267–268

From what I see, it seems like PDBFile is designed to be created when opening the pdb file. It doesn't allow copying it around.
NativeSession holds a unique_ptr of PDBFile and NativeSession::getPDBFile returns the reference of object, so creating unique_ptr from it is not allowed.

I moved loadPDBFile to ObjectFilePDB as static function, so we can move PDBFile easily.

[labath]

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

177–198

I'm not sure this kind of consistency actually helps. For example, in Module::MatchesModuleSpec, module's own architecture (as provided by ObjectFile(PECOFF)::GetArchitecture) is compared to the one in the ModuleSpec (generally coming from ObjectFile(PDB)::GetModuleSpecifications.

If there's any mismatch between the two ways of computing a ArchSpec, then there will be trouble, even though they are "symmetric".

That said, I think we can keep this like it is in this patch, but I'd like to clean up both implementations in a another patch.

208–210

So, that's a bug in SymbolFileNativePDB::InitializeObject. It should be calling m_objfile_sp->GetModule()->GetObjectFile()->GetBaseAddress() (as done in e.g. SymbolFileBreakpad::GetBaseFileAddress) instead of m_objfile_sp->GetBaseAddress(). That will get you the base address of the main (exe) object file instead of the pdb. Up until now, that distinction was not important because m_objfile_sp was always the main file...

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

267–268

You don't need to copy it -- you can just have the two objects reference the same instance (stealing the PDBFile object from under ObjectFilePDB seems suboptimal). Probably the simplest way to achieve that is to change the PdbIndex class to use a raw pointer (and ObjectFilePDB to provide one). Then SymbolFilePDB can have an additional unique_ptr<PDBFile> member, which may or may not be empty (depending on whether it fetches object from ObjectFilePDB or loads it itself). Eventually, as we transition to always fetching the PDBFile from ObjectFilePDB, that member will disappear completely.

Also, I wasn't expecting you to take the giveMeAPDBFile name literally. :) I was deliberatly using a funky name as a placeholder because I wasn't sure of how exactly this would work -- I was trying to illustrate the general concept, and not a precise implementation. If what, I said in the previous paragraph works, then a "normal" name like GetPDBFile should work just fine...

Sorry about the confusion.

267–275

You should be able to delete this block now -- the code you're writing now supersedes (and enhances) it. If the module has a SymbolFileSpec, then this file will be loaded (as an ObjectFilePDB) in SymbolVendor::FindPlugin, and that instance will be passed to the SymbolFilePDB constructor.

lldb/test/Shell/ObjectFile/PDB/object.test

4

Could we generate the pdb directly from yaml (perhaps via llvm-pdbutil yaml2pdb)? That way we could have a hardcoded UUID and explicit test for its parsing.

lldb/test/Shell/ObjectFile/PDB/symbol.test

4 ↗

(On Diff #299826)

This is SymbolFile functionality, so it'd be better placed in Shell/SymbolFile/PDB

[zequanwu]

Address some comments.

[zequanwu]

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

177–198

So, we want to refactor out the common part of ObjectFilePECOFF::GetArchitecture and ObjectFilePDB::GetModuleSpecifications to keep them consistent? I will do it in another patch.

208–210

Thanks for pointing it out. I'll update it and leave GetBaseAddress and CreateSections as unimplemented.

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

267–268

Then SymbolFilePDB can have an additional unique_ptr<PDBFile> member

I think you meant SymbolFileNativePDB, but why do we need this? It already has a member unique_ptr<PDBIndex>. I might misunderstood.

I changed it to have loadPDBFile return raw pointer and ObjectFilePDB has a raw pointer member and PdbIndex uses raw pointer.

lldb/test/Shell/ObjectFile/PDB/object.test

4

I noticed when I use llvm-pdbutil pdb2yaml to generate yaml file from pdb file and then use llvm-pdbutil yaml2pdb to get pdb file back, the two pdb files are not the same. Also using lldb-test symbols with the pdb created from yaml file, got the error: error: Module has no symbol vendor. This doesn't happen if I use the original pdb file.

lldb/test/Shell/ObjectFile/PDB/symbol.test

4 ↗

(On Diff #299826)

I put it here because I saw symbol.yaml which uses lldb-test symbols exists in Shell/ObjectFile/PECOFF. And the folder Shell/SymbolFile seems to contain tests for SymbolFile plugins.

[labath]

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

177–198

I'd actually say all four functions (ObjectFile{PECOFF,PDB}::{GetArchitecture,GetModuleSpecifications}) should use the same algorithm, but lets leave that for the other patch.

lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.cpp

42

What's up with the reference?

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

267–268

Yeah, but who's now responsible for deleting the PDBFile object? You just leak it, right?

My proposal was the following:

• ObjectFilePDB is responsible for freeing the PDBFile object that it creates (but it can borrow that object to the SymbolFile)
• SymbolFileNativePDB is responsible for the object that it creates (which happens only when it's not borrowing the PDBFile). This is what the extra member is for.
• PDBIndex is *not* responsible for freeing anything

The imagined implementation was something like:

class ObjectFilePDB {
  std::unique_ptr<PDBFile> m_file_up; // Always non-null
  PDBFile &GetPDBFile() { return *m_file_up; }
};
class SymbolFilePDB {
  std::unique_ptr<PDBIndex> m_pdb_index;
  std::unique_ptr<PDBFile> m_file_up; // May be null
};
SymbolFilePDB::CalculateAbilities() {
  ...
  PDBFile *pdb_file;
  if (loading_from_objfile)
    pdb_file = &objfile->GetPDBFile();
  else {
    m_file_up = loadMatchingPDBFile(...);
    pdb_file = m_file_up.get();
  }
  m_index = PdbIndex::Create(*pdb_file);
}

Other implementations are possible as well...

lldb/test/Shell/ObjectFile/PDB/object.test

4

Yeah, unfortunately it looks like pdb2yaml does not support some pdb streams (though I also wonder if lldb is not being too strict about the kinds of streams it expects). It would be nice to fix that one day.

Nonetheless, the current pdb2yaml functionality seems sufficient for the purposes of this particular test, so I think we should use that here. The hardcoded uuid here may be brittle as it depends on the exact algorithm that lld uses to compute it.

lldb/test/Shell/ObjectFile/PDB/symbol.test

4 ↗

(On Diff #300133)

This is pretty strange way to use the pdb file and I'm surprised that it actually works (it probably shouldn't). The pdb file should not normally be the main object file of a module. You probably want something like lldb-test symbols %t.exe -symbol-file %t.pdb.

4 ↗

(On Diff #299826)

The fact that that test uses the symbols function of lldb-test is not ideal, but the functionality it tests (symbol table parsing) is definitely an ObjectFile feature. OTOH, Parsing of Types, CompileUnits and Functions definitely falls into the SymbolFile purview. Given that the other test can be moved to yaml2pdb, and you don't have to worry about duplicating inputs, I'd move this test to the SymbolFile folder

That said, I'm not sure what is it that you actually wanted to test here. What's being done here that is not covered by the load-pdb.test? You could potentially add -o "b main" (to force symfile parsing) and -o "image dump symfile" to the other test if you wanted to check that the pdb can actually be parsed this way.

lldb/test/Shell/SymbolFile/NativePDB/load-pdb.cpp

15

It's simpler to just pass the executable as an argument instead of wrapping it in -o "target create".

[zequanwu]

Address comments.

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

177–198

It's interesting that GetArchitecture and GetModuleSpecifications in ObjectFilePECOFF currently do not have the same algorithm, but works fine.

lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.cpp

42

Removed reference.

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

267–268

Thanks for declaration.

lldb/test/Shell/ObjectFile/PDB/object.test

4

I switched to use yaml2pdb. The uuid is swapped byte order when reading from pdb.

lldb/test/Shell/ObjectFile/PDB/symbol.test

4 ↗

(On Diff #299826)

I'll put the testing of symfile parsing in load-pdb.cpp.

[amccarth]

This looks pretty good, both the patch and Pavel's insights. I don't see much to comment on that Pavel didn't already catch.

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

169

For me, the name spec is confusing, because this code is mostly dealing with ModuleSpecs but spec is a reference to the ArchSpec of the module_spec. Perhaps module_arch would make this clearer. Then the code below would follow a pattern like:

module_arch.SetTriple("blah");
specs.Append(module_spec);

[labath]

lgtm

lldb/source/Plugins/ObjectFile/PDB/CMakeLists.txt

7

I don't see this using any Host functionality.

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

145

do revert this before committing.

855

this too

lldb/test/Shell/ObjectFile/PDB/object.test

2

Consider "inlining" the yaml input into this file.

[zequanwu]

Address comments.

[jankratochvil]

It has regressed buildbots:

SymbolFile/NativePDB/load-pdb.cpp
lldb-x86_64-fedora: http://lab.llvm.org:8014/#/builders/14/builds/1006
lldb-x86_64-debian: http://lab.llvm.org:8011/#/builders/68/builds/782

[zequanwu]

In D89812#2354320, @jankratochvil wrote:

It has regressed buildbots:

SymbolFile/NativePDB/load-pdb.cpp
lldb-x86_64-fedora: http://lab.llvm.org:8014/#/builders/14/builds/1006
lldb-x86_64-debian: http://lab.llvm.org:8011/#/builders/68/builds/782

Just put a fix here: https://reviews.llvm.org/rG4b83747ab1577b7899116b0ddb75f05de2471694
This should fix it.

[stella.stamenova]

load-pdb is still failing on the Windows bot. Can you please commit a fix soon or revert the change?

[zequanwu]

In D89812#2354862, @stella.stamenova wrote:

load-pdb is still failing on the Windows bot. Can you please commit a fix soon or revert the change?

Okay, I'm looking at it now

[zequanwu]

In D89812#2354862, @stella.stamenova wrote:

load-pdb is still failing on the Windows bot. Can you please commit a fix soon or revert the change?

It's slash vs back slash thing. Put a fix at https://reviews.llvm.org/rG779deb9750a4853485ac7beca86f518b067ad6d6

lldb/source/Plugins/ObjectFile/CMakeLists.txt

 add_subdirectory(Breakpad)
 add_subdirectory(ELF)
 add_subdirectory(Mach-O)
+add_subdirectory(PDB)
 add_subdirectory(PECOFF)
 add_subdirectory(JIT)
 add_subdirectory(wasm)

lldb/source/Plugins/ObjectFile/PDB/CMakeLists.txt

+add_lldb_library(lldbPluginObjectFilePDB PLUGIN
+  ObjectFilePDB.cpp
+
+  LINK_LIBS
+    lldbCore
+    lldbSymbol
+    lldbUtility
+  LINK_COMPONENTS
+    Support
+  )

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.h

+//===-- ObjectFilePDB.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 LLDB_SOURCE_PLUGINS_OBJECTFILE_PDB_OBJECTFILEPDB_H
+#define LLDB_SOURCE_PLUGINS_OBJECTFILE_PDB_OBJECTFILEPDB_H
+
+#include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Utility/ArchSpec.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+#include "llvm/DebugInfo/PDB/PDBTypes.h"
+
+namespace lldb_private {
+
+class ObjectFilePDB : public ObjectFile {
+public:
+  // Static Functions
+  static void Initialize();
+  static void Terminate();
+
+  static ConstString GetPluginNameStatic();
+  static const char *GetPluginDescriptionStatic() {
+    return "PDB object file reader.";
+  }
+
+  static std::unique_ptr<llvm::pdb::PDBFile>
+  loadPDBFile(std::string PdbPath, llvm::BumpPtrAllocator &Allocator);
+
+  static ObjectFile *
+  CreateInstance(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
+                 lldb::offset_t data_offset, const FileSpec *file,
+                 lldb::offset_t file_offset, lldb::offset_t length);
+
+  static ObjectFile *CreateMemoryInstance(const lldb::ModuleSP &module_sp,
+                                          lldb::DataBufferSP &data_sp,
+                                          const lldb::ProcessSP &process_sp,
+                                          lldb::addr_t header_addr);
+
+  static size_t GetModuleSpecifications(const FileSpec &file,
+                                        lldb::DataBufferSP &data_sp,
+                                        lldb::offset_t data_offset,
+                                        lldb::offset_t file_offset,
+                                        lldb::offset_t length,
+                                        ModuleSpecList &specs);
+
+  // PluginInterface protocol
+  ConstString GetPluginName() override { return GetPluginNameStatic(); }
+
+  uint32_t GetPluginVersion() override { return 1; }
+
+  // LLVM RTTI support
+  static char ID;
+  bool isA(const void *ClassID) const override {
+    return ClassID == &ID || ObjectFile::isA(ClassID);
+  }
+  static bool classof(const ObjectFile *obj) { return obj->isA(&ID); }
+
+  // ObjectFile Protocol.
+  uint32_t GetAddressByteSize() const override { return 8; }
+
+  lldb::ByteOrder GetByteOrder() const override {
+    return lldb::eByteOrderLittle;
+  }
+
+  bool ParseHeader() override { return true; }
+
+  bool IsExecutable() const override { return false; }
+
+  Symtab *GetSymtab() override { return nullptr; }
+
+  bool IsStripped() override { return false; }
+
+  // No section in PDB file.
+  void CreateSections(SectionList &unified_section_list) override {}
+
+  void Dump(Stream *s) override {}
+
+  ArchSpec GetArchitecture() override;
+
+  UUID GetUUID() override { return m_uuid; }
+
+  uint32_t GetDependentModules(FileSpecList &files) override { return 0; }
+
+  Type CalculateType() override { return eTypeDebugInfo; }
+
+  Strata CalculateStrata() override { return eStrataUser; }
+
+  llvm::pdb::PDBFile &GetPDBFile() { return *m_file_up; }
+
+  ObjectFilePDB(const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
+                lldb::offset_t data_offset, const FileSpec *file,
+                lldb::offset_t offset, lldb::offset_t length);
+
+private:
+  UUID m_uuid;
+  llvm::BumpPtrAllocator m_allocator;
+  std::unique_ptr<llvm::pdb::PDBFile> m_file_up;
+
+  bool initPDBFile();
+};
+
+} // namespace lldb_private
+#endif // LLDB_PLUGINS_OBJECTFILE_PDB_OBJECTFILEPDB_H

lldb/source/Plugins/ObjectFile/PDB/ObjectFilePDB.cpp

+//===-- ObjectFilePDB.cpp -------------------------------------------------===//
+//
+// 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 "ObjectFilePDB.h"
+#include "lldb/Core/Module.h"
+#include "lldb/Core/ModuleSpec.h"
+#include "lldb/Core/PluginManager.h"
+#include "lldb/Core/Section.h"
+#include "lldb/Utility/StreamString.h"
+#include "llvm/BinaryFormat/Magic.h"
+#include "llvm/DebugInfo/PDB/Native/DbiStream.h"
+#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
+#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
+#include "llvm/DebugInfo/PDB/PDB.h"
+#include "llvm/Support/BinaryByteStream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace llvm::pdb;
+using namespace llvm::codeview;
+
+LLDB_PLUGIN_DEFINE(ObjectFilePDB)
+
+struct CVInfoPdb70 {
+  // 16-byte GUID
+  struct _Guid {
+    llvm::support::ulittle32_t Data1;
+    llvm::support::ulittle16_t Data2;
+    llvm::support::ulittle16_t Data3;
+    uint8_t Data4[8];
+  } Guid;
+
+  llvm::support::ulittle32_t Age;
+};
+
+static UUID GetPDBUUID(InfoStream &IS) {
+  // This part is similar with what has done in ObjectFilePECOFF.
+  using llvm::support::endian::read16be;
+  using llvm::support::endian::read32;
+  using llvm::support::endian::read32be;
+
+  GUID guid = IS.getGuid();
+  const uint8_t *guid_p = guid.Guid;
+  struct CVInfoPdb70 info;
+  info.Guid.Data1 = read32be(guid_p);
+  guid_p += 4;
+  info.Guid.Data2 = read16be(guid_p);
+  guid_p += 2;
+  info.Guid.Data3 = read16be(guid_p);
+  guid_p += 2;
+  memcpy(info.Guid.Data4, guid_p, 8);
+
+  // Return 20-byte UUID if the Age is not zero
+  uint32_t age = IS.getAge();
+  if (age) {
+    info.Age = read32(&age, llvm::support::big);
+    return UUID::fromOptionalData(&info, sizeof(info));
+  }
+  // Otherwise return 16-byte GUID
+  return UUID::fromOptionalData(&info.Guid, sizeof(info.Guid));
+}
+
+char ObjectFilePDB::ID;
+
+void ObjectFilePDB::Initialize() {
+  PluginManager::RegisterPlugin(GetPluginNameStatic(),
+                                GetPluginDescriptionStatic(), CreateInstance,
+                                CreateMemoryInstance, GetModuleSpecifications);
+}
+
+void ObjectFilePDB::Terminate() {
+  PluginManager::UnregisterPlugin(CreateInstance);
+}
+
+ConstString ObjectFilePDB::GetPluginNameStatic() {
+  static ConstString g_name("pdb");
+  return g_name;
+}
+
+ArchSpec ObjectFilePDB::GetArchitecture() {
+  auto dbi_stream = m_file_up->getPDBDbiStream();
+  if (!dbi_stream) {
+    llvm::consumeError(dbi_stream.takeError());
+    return ArchSpec();
+  }
+
+  PDB_Machine machine = dbi_stream->getMachineType();
+  switch (machine) {
+  default:
+    break;
+  case PDB_Machine::Amd64:
+  case PDB_Machine::x86:
+  case PDB_Machine::PowerPC:
+  case PDB_Machine::PowerPCFP:
+  case PDB_Machine::Arm:
+  case PDB_Machine::ArmNT:
+  case PDB_Machine::Thumb:
+  case PDB_Machine::Arm64:
+    ArchSpec arch;
+    arch.SetArchitecture(eArchTypeCOFF, static_cast<int>(machine),
+                         LLDB_INVALID_CPUTYPE);
+    return arch;
+  }
+  return ArchSpec();
+}
+
+bool ObjectFilePDB::initPDBFile() {
+  m_file_up = loadPDBFile(m_file.GetPath(), m_allocator);
+  if (!m_file_up)
+    return false;
+  auto info_stream = m_file_up->getPDBInfoStream();
+  if (!info_stream) {
+    llvm::consumeError(info_stream.takeError());
+    return false;
+  }
+  m_uuid = GetPDBUUID(*info_stream);
+  return true;
+}
+
+ObjectFile *
+ObjectFilePDB::CreateInstance(const ModuleSP &module_sp, DataBufferSP &data_sp,
+                              offset_t data_offset, const FileSpec *file,
+                              offset_t file_offset, offset_t length) {
+  auto objfile_up = std::make_unique<ObjectFilePDB>(
+      module_sp, data_sp, data_offset, file, file_offset, length);
+  if (!objfile_up->initPDBFile())
+    return nullptr;
+  return objfile_up.release();
+}
+
+ObjectFile *ObjectFilePDB::CreateMemoryInstance(const ModuleSP &module_sp,
+                                                DataBufferSP &data_sp,
+                                                const ProcessSP &process_sp,
+                                                addr_t header_addr) {
+  return nullptr;
+}
+
+size_t ObjectFilePDB::GetModuleSpecifications(
+    const FileSpec &file, DataBufferSP &data_sp, offset_t data_offset,
+    offset_t file_offset, offset_t length, ModuleSpecList &specs) {
+  const size_t initial_count = specs.GetSize();
+  ModuleSpec module_spec(file);
+  llvm::BumpPtrAllocator allocator;
+  std::unique_ptr<PDBFile> pdb_file = loadPDBFile(file.GetPath(), allocator);
+  if (!pdb_file)
+    return initial_count;
+
+  auto info_stream = pdb_file->getPDBInfoStream();
+  if (!info_stream) {
+    llvm::consumeError(info_stream.takeError());
+    return initial_count;
+  }
+  auto dbi_stream = pdb_file->getPDBDbiStream();
+  if (!dbi_stream) {
+    llvm::consumeError(dbi_stream.takeError());
+    return initial_count;
+  }
+
+  lldb_private::UUID &uuid = module_spec.GetUUID();
+  uuid = GetPDBUUID(*info_stream);
+
+  ArchSpec &module_arch = module_spec.GetArchitecture();
+  switch (dbi_stream->getMachineType()) {
+  case PDB_Machine::Amd64:
+    module_arch.SetTriple("x86_64-pc-windows");
+    specs.Append(module_spec);
+    break;
+  case PDB_Machine::x86:
+    module_arch.SetTriple("i386-pc-windows");
+    specs.Append(module_spec);
+    module_arch.SetTriple("i686-pc-windows");
+    specs.Append(module_spec);
+    break;
+  case PDB_Machine::ArmNT:
+    module_arch.SetTriple("armv7-pc-windows");
+    specs.Append(module_spec);
+    break;
+  case PDB_Machine::Arm64:
+    module_arch.SetTriple("aarch64-pc-windows");
+    specs.Append(module_spec);
+    break;
+  default:
+    break;
+  }
+
+  return specs.GetSize() - initial_count;
+}
+
+ObjectFilePDB::ObjectFilePDB(const ModuleSP &module_sp, DataBufferSP &data_sp,
+                             offset_t data_offset, const FileSpec *file,
+                             offset_t offset, offset_t length)
+    : ObjectFile(module_sp, file, offset, length, data_sp, data_offset) {}
+
+std::unique_ptr<PDBFile>
+ObjectFilePDB::loadPDBFile(std::string PdbPath,
+                           llvm::BumpPtrAllocator &Allocator) {
+  llvm::file_magic magic;
+  auto ec = llvm::identify_magic(PdbPath, magic);
+  if (ec || magic != llvm::file_magic::pdb)
+    return nullptr;
+  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ErrorOrBuffer =
+      llvm::MemoryBuffer::getFile(PdbPath, /*FileSize=*/-1,
+                                  /*RequiresNullTerminator=*/false);
+  if (!ErrorOrBuffer)
+    return nullptr;
+  std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
+
+  llvm::StringRef Path = Buffer->getBufferIdentifier();
+  auto Stream = std::make_unique<llvm::MemoryBufferByteStream>(
+      std::move(Buffer), llvm::support::little);
+
+  auto File = std::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
+  if (auto EC = File->parseFileHeaders()) {
+    llvm::consumeError(std::move(EC));
+    return nullptr;
+  }
+  if (auto EC = File->parseStreamData()) {
+    llvm::consumeError(std::move(EC));
+    return nullptr;
+  }
+
+  return File;
+}

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

ObjectFile *ObjectFilePECOFF::CreateInstance(const lldb::ModuleSP &module_sp,
   auto objfile_up = std::make_unique<ObjectFilePECOFF>(
       module_sp, data_sp, data_offset, file_p, file_offset, length);
   if (!objfile_up || !objfile_up->ParseHeader())
     return nullptr;
 
   // Cache coff binary.
   if (!objfile_up->CreateBinary())
     return nullptr;
-
   return objfile_up.release();
 }
 
 ObjectFile *ObjectFilePECOFF::CreateMemoryInstance(
     const lldb::ModuleSP &module_sp, lldb::DataBufferSP &data_sp,
     const lldb::ProcessSP &process_sp, lldb::addr_t header_addr) {
   if (!data_sp || !ObjectFilePECOFF::MagicBytesMatch(data_sp))
     return nullptr;
SectionType ObjectFilePECOFF::GetSectionType(llvm::StringRef sect_name,
   }
   return eSectionTypeOther;
 }
 
 void ObjectFilePECOFF::CreateSections(SectionList &unified_section_list) {
   if (m_sections_up)
     return;
   m_sections_up = std::make_unique<SectionList>();
-
   ModuleSP module_sp(GetModule());
   if (module_sp) {
     std::lock_guard<std::recursive_mutex> guard(module_sp->GetMutex());
 
     SectionSP header_sp = std::make_shared<Section>(
         module_sp, this, ~user_id_t(0), ConstString("PECOFF header"),
         eSectionTypeOther, m_coff_header_opt.image_base,
         m_coff_header_opt.header_size,

lldb/source/Plugins/SymbolFile/NativePDB/CMakeLists.txt

add_lldb_library(lldbPluginSymbolFileNativePDB
   SymbolFileNativePDB.cpp
   UdtRecordCompleter.cpp
 
   LINK_LIBS
     lldbCore
     lldbSymbol
     lldbUtility
     lldbPluginTypeSystemClang
+    lldbPluginObjectFilePDB
   CLANG_LIBS
     clangAST
     clangLex
   LINK_COMPONENTS
     DebugInfoCodeView
     DebugInfoPDB
     Support
   )

lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.h

 /// certain data when it is accessed the first time.  The entire PDB file is
 /// mapped into memory, and the underlying support libraries vend out memory
 /// that is always backed by the file, so it is safe to hold StringRefs and
 /// ArrayRefs into the backing memory as long as the PdbIndex instance is
 /// alive.
 class PdbIndex {
 
   /// The underlying PDB file.
-  std::unique_ptr<llvm::pdb::PDBFile> m_file;
+  llvm::pdb::PDBFile *m_file = nullptr;
 
   /// The DBI stream.  This contains general high level information about the
   /// features present in the PDB file, compile units (such as the information
   /// necessary to locate full symbol information for each compile unit),
   /// section contributions, and other data which is not specifically symbol or
   /// type records.
   llvm::pdb::DbiStream *m_dbi = nullptr;
 
class PdbIndex {
   /// The address at which the program has been loaded into memory.
   lldb::addr_t m_load_address = 0;
 
   PdbIndex();
 
   void BuildAddrToSymbolMap(CompilandIndexItem &cci);
 
 public:
-  static llvm::Expected<std::unique_ptr<PdbIndex>>
-      create(std::unique_ptr<llvm::pdb::PDBFile>);
+  static llvm::Expected<std::unique_ptr<PdbIndex>> create(llvm::pdb::PDBFile *);
 
   void SetLoadAddress(lldb::addr_t addr) { m_load_address = addr; }
   lldb::addr_t GetLoadAddress() const { return m_load_address; }
   void ParseSectionContribs();
 
   llvm::pdb::PDBFile &pdb() { return *m_file; }
   const llvm::pdb::PDBFile &pdb() const { return *m_file; }
 

lldb/source/Plugins/SymbolFile/NativePDB/PdbIndex.cpp

#define ASSIGN_PTR_OR_RETURN(result_ptr, expr)                                 \
   {                                                                            \
     auto expected_result = expr;                                               \
     if (!expected_result)                                                      \
       return expected_result.takeError();                                      \
     result_ptr = &expected_result.get();                                       \
   }
 
 llvm::Expected<std::unique_ptr<PdbIndex>>
-PdbIndex::create(std::unique_ptr<llvm::pdb::PDBFile> file) {
+PdbIndex::create(llvm::pdb::PDBFile *file) {
   lldbassert(file);
 
   std::unique_ptr<PdbIndex> result(new PdbIndex());
   ASSIGN_PTR_OR_RETURN(result->m_dbi, file->getPDBDbiStream());
   ASSIGN_PTR_OR_RETURN(result->m_tpi, file->getPDBTpiStream());
   ASSIGN_PTR_OR_RETURN(result->m_ipi, file->getPDBIpiStream());
   ASSIGN_PTR_OR_RETURN(result->m_info, file->getPDBInfoStream());
   ASSIGN_PTR_OR_RETURN(result->m_publics, file->getPDBPublicsStream());
   ASSIGN_PTR_OR_RETURN(result->m_globals, file->getPDBGlobalsStream());
   ASSIGN_PTR_OR_RETURN(result->m_symrecords, file->getPDBSymbolStream());
 
   result->m_tpi->buildHashMap();
 
-  result->m_file = std::move(file);
+  result->m_file = file;
 
   return std::move(result);
 }
 
 lldb::addr_t PdbIndex::MakeVirtualAddress(uint16_t segment,
                                           uint32_t offset) const {
   // Segment indices are 1-based.
   lldbassert(segment > 0);

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

size_t ParseVariablesForCompileUnit(CompileUnit &comp_unit,
                                       VariableList &variables);
   size_t ParseVariablesForBlock(PdbCompilandSymId block_id);
 
   llvm::BumpPtrAllocator m_allocator;
 
   lldb::addr_t m_obj_load_address = 0;
   bool m_done_full_type_scan = false;
 
+  std::unique_ptr<llvm::pdb::PDBFile> m_file_up;
   std::unique_ptr<PdbIndex> m_index;
 
   std::unique_ptr<PdbAstBuilder> m_ast;
 
   llvm::DenseMap<lldb::user_id_t, lldb::VariableSP> m_global_vars;
   llvm::DenseMap<lldb::user_id_t, lldb::VariableSP> m_local_variables;
   llvm::DenseMap<lldb::user_id_t, lldb::BlockSP> m_blocks;
   llvm::DenseMap<lldb::user_id_t, lldb::FunctionSP> m_functions;
   llvm::DenseMap<lldb::user_id_t, lldb::CompUnitSP> m_compilands;
   llvm::DenseMap<lldb::user_id_t, lldb::TypeSP> m_types;
 };
 
 } // namespace npdb
 } // namespace lldb_private
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_NATIVEPDB_SYMBOLFILENATIVEPDB_H

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 #include "clang/AST/Attr.h"
 #include "clang/AST/CharUnits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/Type.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/Language/CPlusPlus/MSVCUndecoratedNameParser.h"
+#include "Plugins/ObjectFile/PDB/ObjectFilePDB.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamBuffer.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"

 #include "llvm/DebugInfo/CodeView/RecordName.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
 #include "llvm/DebugInfo/PDB/Native/GlobalsStream.h"
 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
+#include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/SymbolStream.h"
 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
+#include "llvm/DebugInfo/PDB/PDB.h"
 #include "llvm/DebugInfo/PDB/PDBTypes.h"
 #include "llvm/Demangle/MicrosoftDemangle.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/BinaryStreamReader.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
case PDB_Lang::C:
     return lldb::LanguageType::eLanguageTypeC;
   case PDB_Lang::Swift:
     return lldb::LanguageType::eLanguageTypeSwift;
   default:
     return lldb::LanguageType::eLanguageTypeUnknown;
   }
 }
 
-static std::unique_ptr<PDBFile> loadPDBFile(std::string PdbPath,
-                                            llvm::BumpPtrAllocator &Allocator) {
-  llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> ErrorOrBuffer =
-      llvm::MemoryBuffer::getFile(PdbPath, /*FileSize=*/-1,
-                                  /*RequiresNullTerminator=*/false);
-  if (!ErrorOrBuffer)
-    return nullptr;
-  std::unique_ptr<llvm::MemoryBuffer> Buffer = std::move(*ErrorOrBuffer);
-
-  llvm::StringRef Path = Buffer->getBufferIdentifier();
-  auto Stream = std::make_unique<llvm::MemoryBufferByteStream>(
-      std::move(Buffer), llvm::support::little);
-
-  auto File = std::make_unique<PDBFile>(Path, std::move(Stream), Allocator);
-  if (auto EC = File->parseFileHeaders()) {
-    llvm::consumeError(std::move(EC));
-    return nullptr;
-  }
-  if (auto EC = File->parseStreamData()) {
-    llvm::consumeError(std::move(EC));
-    return nullptr;
-  }
-
-  return File;
-}
-
 static std::unique_ptr<PDBFile>
 loadMatchingPDBFile(std::string exe_path, llvm::BumpPtrAllocator &allocator) {
   // Try to find a matching PDB for an EXE.
   using namespace llvm::object;
   auto expected_binary = createBinary(exe_path);
 
   // If the file isn't a PE/COFF executable, fail.
   if (!expected_binary) {
loadMatchingPDBFile(std::string exe_path, llvm::BumpPtrAllocator &allocator) {
   // executable.
   if (!FileSystem::Instance().Exists(pdb_file)) {
     const auto exe_dir = FileSpec(exe_path).CopyByRemovingLastPathComponent();
     const auto pdb_name = FileSpec(pdb_file).GetFilename().GetCString();
     pdb_file = exe_dir.CopyByAppendingPathComponent(pdb_name).GetCString();
   }
 
   // If the file is not a PDB or if it doesn't have a matching GUID, fail.
-  llvm::file_magic magic;
-  auto ec = llvm::identify_magic(pdb_file, magic);
-  if (ec || magic != llvm::file_magic::pdb)
-    return nullptr;
-  std::unique_ptr<PDBFile> pdb = loadPDBFile(std::string(pdb_file), allocator);
+  auto pdb = ObjectFilePDB::loadPDBFile(std::string(pdb_file), allocator);
   if (!pdb)
     return nullptr;
 
   auto expected_info = pdb->getPDBInfoStream();
   if (!expected_info) {
     llvm::consumeError(expected_info.takeError());
     return nullptr;
   }

 SymbolFileNativePDB::~SymbolFileNativePDB() {}
 
 uint32_t SymbolFileNativePDB::CalculateAbilities() {
   uint32_t abilities = 0;
   if (!m_objfile_sp)
     return 0;
 
   if (!m_index) {
     // Lazily load and match the PDB file, but only do this once.
-    std::unique_ptr<PDBFile> file_up =
-        loadMatchingPDBFile(m_objfile_sp->GetFileSpec().GetPath(), m_allocator);
-
-    if (!file_up) {
-      auto module_sp = m_objfile_sp->GetModule();
-      if (!module_sp)
-        return 0;
-      // See if any symbol file is specified through `--symfile` option.
-      FileSpec symfile = module_sp->GetSymbolFileFileSpec();
-      if (!symfile)
-        return 0;
-      file_up = loadPDBFile(symfile.GetPath(), m_allocator);
+    PDBFile *pdb_file;
+    if (auto *pdb = llvm::dyn_cast<ObjectFilePDB>(m_objfile_sp.get())) {
+      pdb_file = &pdb->GetPDBFile();
+    } else {
+      m_file_up = loadMatchingPDBFile(m_objfile_sp->GetFileSpec().GetPath(),
+                                      m_allocator);
+      pdb_file = m_file_up.get();
     }
 
-    if (!file_up)
+    if (!pdb_file)
       return 0;
 
-    auto expected_index = PdbIndex::create(std::move(file_up));
+    auto expected_index = PdbIndex::create(pdb_file);
     if (!expected_index) {
       llvm::consumeError(expected_index.takeError());
       return 0;
     }
     m_index = std::move(*expected_index);
   }
   if (!m_index)
     return 0;
 
   // We don't especially have to be precise here.  We only distinguish between
   // stripped and not stripped.
   abilities = kAllAbilities;
 
   if (m_index->dbi().isStripped())
     abilities &= ~(Blocks | LocalVariables);
   return abilities;
 }
 
 void SymbolFileNativePDB::InitializeObject() {
-  m_obj_load_address = m_objfile_sp->GetBaseAddress().GetFileAddress();
+  m_obj_load_address = m_objfile_sp->GetModule()
+                           ->GetObjectFile()
+                           ->GetBaseAddress()
+                           .GetFileAddress();
   m_index->SetLoadAddress(m_obj_load_address);
   m_index->ParseSectionContribs();
 
   auto ts_or_err = m_objfile_sp->GetModule()->GetTypeSystemForLanguage(
       lldb::eLanguageTypeC_plus_plus);
   if (auto err = ts_or_err.takeError()) {
     LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
                    std::move(err), "Failed to initialize");

lldb/test/Shell/ObjectFile/PDB/object.test

+# RUN: llvm-pdbutil yaml2pdb %s -pdb=%t.pdb
+# RUN: lldb-test object-file %t.pdb | FileCheck %s
+
+# CHECK: Plugin name: pdb
+# CHECK: Architecture: x86_64-pc-windows-msvc
+# CHECK: UUID: 3F58AF61-A829-6C7A-4C4C-44205044422E-00000001
+# CHECK: Executable: false
+# CHECK: Stripped: false
+# CHECK: Type: debug info
+# CHECK: Strata: user
+# CHECK: Base VM address: 0xffffffffffffffff
+# CHECK: There are no sections
+
+---
+MSF:
+  SuperBlock:
+    BlockSize:       4096
+    FreeBlockMap:    2
+    NumBlocks:       18
+    NumDirectoryBytes: 116
+    Unknown1:        0
+    BlockMapAddr:    3
+  NumDirectoryBlocks: 1
+  DirectoryBlocks: [ 17 ]
+  NumStreams:      15
+  FileSize:        73728
+StreamSizes:     [ 0, 93, 100, 550, 136, 0, 544, 576, 40, 20, 120, 368, 
+                   336, 49, 24 ]
+StreamMap:
+  - Stream:          [  ]
+  - Stream:          [ 16 ]
+  - Stream:          [ 7 ]
+  - Stream:          [ 12 ]
+  - Stream:          [ 14 ]
+  - Stream:          [  ]
+  - Stream:          [ 4 ]
+  - Stream:          [ 5 ]
+  - Stream:          [ 6 ]
+  - Stream:          [ 8 ]
+  - Stream:          [ 9 ]
+  - Stream:          [ 10 ]
+  - Stream:          [ 11 ]
+  - Stream:          [ 13 ]
+  - Stream:          [ 15 ]
+StringTable:
+  - '/tmp/a.cpp'
+PdbStream:
+  Age:             1
+  Guid:            '{61AF583F-29A8-7A6C-4C4C-44205044422E}'
+  Signature:       1062776673
+  Features:        [ VC140 ]
+  Version:         VC70
+DbiStream:
+  VerHeader:       V70
+  Age:             1
+  BuildNumber:     36363
+  PdbDllVersion:   0
+  PdbDllRbld:      0
+  Flags:           0
+  MachineType:     Amd64
+  Modules:
+    - Module:          '/tmp/pdb.obj'
+      ObjFile:         '/tmp/pdb.obj'
+      SourceFiles:
+        - '/tmp/a.cpp'
+      Subsections:
+        - !Lines
+          CodeSize:        28
+          Flags:           [  ]
+          RelocOffset:     0
+          RelocSegment:    1
+          Blocks:
+            - FileName:        '/tmp/a.cpp'
+              Lines:
+                - Offset:          0
+                  LineStart:       1
+                  IsStatement:     false
+                  EndDelta:        0
+                - Offset:          23
+                  LineStart:       2
+                  IsStatement:     false
+                  EndDelta:        0
+              Columns:         []
+        - !FileChecksums
+          Checksums:
+            - FileName:        '/tmp/a.cpp'
+              Kind:            MD5
+              Checksum:        DA1F9D293B90B487ADB2C711137770D3
+      Modi:
+        Signature:       4
+        Records:
+          - Kind:            S_COMPILE3
+            Compile3Sym:
+              Flags:           [  ]
+              Machine:         X64
+              FrontendMajor:   12
+              FrontendMinor:   0
+              FrontendBuild:   0
+              FrontendQFE:     0
+              BackendMajor:    12000
+              BackendMinor:    0
+              BackendBuild:    0
+              BackendQFE:      0
+              Version:         'clang version 12.0.0 ([e-mail]:llvm/llvm-project.git 8a08e08db6c2e4a5db485253f3186b0f9e739e15)'
+          - Kind:            S_GPROC32
+            ProcSym:
+              PtrParent:       0
+              PtrEnd:          272
+              PtrNext:         0
+              CodeSize:        28
+              DbgStart:        0
+              DbgEnd:          0
+              FunctionType:    4098
+              Offset:          0
+              Segment:         1
+              Flags:           [  ]
+              DisplayName:     main
+          - Kind:            S_FRAMEPROC
+            FrameProcSym:
+              TotalFrameBytes: 24
+              PaddingFrameBytes: 0
+              OffsetToPadding: 0
+              BytesOfCalleeSavedRegisters: 0
+              OffsetOfExceptionHandler: 0
+              SectionIdOfExceptionHandler: 0
+              Flags:           [  ]
+          - Kind:            S_LOCAL
+            LocalSym:
+              Type:            116
+              Flags:           [ IsParameter ]
+              VarName:         argc
+          - Kind:            S_DEFRANGE_FRAMEPOINTER_REL
+            DefRangeFramePointerRelSym:
+              Offset:          4
+              Range:
+                OffsetStart:     23
+                ISectStart:      1
+                Range:           5
+              Gaps:            []
+          - Kind:            S_LOCAL
+            LocalSym:
+              Type:            4096
+              Flags:           [ IsParameter ]
+              VarName:         argv
+          - Kind:            S_DEFRANGE_FRAMEPOINTER_REL
+            DefRangeFramePointerRelSym:
+              Offset:          8
+              Range:
+                OffsetStart:     23
+                ISectStart:      1
+                Range:           5
+              Gaps:            []
+          - Kind:            S_END
+            ScopeEndSym:     {}
+          - Kind:            S_BUILDINFO
+            BuildInfoSym:
+              BuildId:         4099
+    - Module:          '* Linker *'
+      ObjFile:         ''
+      Modi:
+        Signature:       4
+        Records:
+          - Kind:            S_OBJNAME
+            ObjNameSym:
+              Signature:       0
+              ObjectName:      '* Linker *'
+          - Kind:            S_COMPILE3
+            Compile3Sym:
+              Flags:           [  ]
+              Machine:         X64
+              FrontendMajor:   0
+              FrontendMinor:   0
+              FrontendBuild:   0
+              FrontendQFE:     0
+              BackendMajor:    14
+              BackendMinor:    10
+              BackendBuild:    25019
+              BackendQFE:      0
+              Version:         LLVM Linker
+          - Kind:            S_ENVBLOCK
+            EnvBlockSym:
+              Entries:
+                - cwd
+                - '/tmp'
+                - exe
+                - '/tmp/lld-link'
+                - pdb
+                - '/tmp/a.pdb'
+                - cmd
+                - '/out:a.exe -debug pdb.obj /nodefaultlib /entry:main'
+          - Kind:            S_SECTION
+            SectionSym:
+              SectionNumber:   1
+              Alignment:       12
+              Rva:             4096
+              Length:          28
+              Characteristics: 1610612768
+              Name:            .text
+          - Kind:            S_COFFGROUP
+            CoffGroupSym:
+              Size:            28
+              Characteristics: 1610612768
+              Offset:          0
+              Segment:         1
+              Name:            .text
+          - Kind:            S_SECTION
+            SectionSym:
+              SectionNumber:   2
+              Alignment:       12
+              Rva:             8192
+              Length:          72
+              Characteristics: 1073741888
+              Name:            .rdata
+          - Kind:            S_COFFGROUP
+            CoffGroupSym:
+              Size:            8
+              Characteristics: 1073741888
+              Offset:          64
+              Segment:         2
+              Name:            .xdata
+          - Kind:            S_SECTION
+            SectionSym:
+              SectionNumber:   3
+              Alignment:       12
+              Rva:             12288
+              Length:          12
+              Characteristics: 1073741888
+              Name:            .pdata
+          - Kind:            S_COFFGROUP
+            CoffGroupSym:
+              Size:            12
+              Characteristics: 1073741888
+              Offset:          0
+              Segment:         3
+              Name:            .pdata
+TpiStream:
+  Version:         VC80
+  Records:
+    - Kind:            LF_POINTER
+      Pointer:
+        ReferentType:    1648
+        Attrs:           65548
+    - Kind:            LF_ARGLIST
+      ArgList:
+        ArgIndices:      [ 116, 4096 ]
+    - Kind:            LF_PROCEDURE
+      Procedure:
+        ReturnType:      116
+        CallConv:        NearC
+        Options:         [ None ]
+        ParameterCount:  2
+        ArgumentList:    4097
+IpiStream:
+  Version:         VC80
+  Records:
+    - Kind:            LF_FUNC_ID
+      FuncId:
+        ParentScope:     0
+        FunctionType:    4098
+        Name:            main
+    - Kind:            LF_STRING_ID
+      StringId:
+        Id:              0
+        String:          '/tmp'
+    - Kind:            LF_STRING_ID
+      StringId:
+        Id:              0
+        String:          a.cpp
+    - Kind:            LF_BUILDINFO
+      BuildInfo:
+        ArgIndices:      [ 4097, 0, 4098, 0, 0 ]
+PublicsStream:
+  Records:
+    - Kind:            S_PUB32
+      PublicSym32:
+        Flags:           [ Function ]
+        Offset:          0
+        Segment:         1
+        Name:            main
+...

lldb/test/Shell/SymbolFile/NativePDB/load-pdb.cpp

+// clang-format off
+// REQUIRES: lld, x86
+
+// Test that lldb load PDB file by command `target symbols add`
+
+// RUN: mkdir -p %t/executable
+// RUN: rm -f %t/executable/foo.exe %t/executable/bar.pdb
+// RUN: %clang_cl --target=x86_64-windows-msvc -Od -Z7 -c /Fo%t/executable/foo.obj -- %s
+// RUN: lld-link -debug:full -nodefaultlib -entry:main %t/executable/foo.obj \
+// RUN:     -out:%t/executable/foo.exe -pdb:%t/executable/foo.pdb
+// Rename the PDB file so that the name is different from the name inside the executable (foo.exe).
+// RUN: mv %t/executable/foo.pdb %t/executable/bar.pdb
+// RUN: env LLDB_USE_NATIVE_PDB_READER=1 %lldb %t/executable/foo.exe \
+// RUN: -o "target symbols add %t/executable/bar.pdb" \
+// RUN: -o "b main" \
+// RUN: -o "image dump symfile" -o "quit" | FileCheck %s
+
+int main(int argc, char** argv) {
+  return 0;
+}
+
+// CHECK: (lldb) target symbols add {{.*}}bar.pdb
+// CHECK: symbol file '{{.*}}/bar.pdb' has been added to '{{.*}}/foo.exe'
+// CHECK: (lldb) b main
+// CHECK: Breakpoint 1: where = foo.exe`main + 23 at load-pdb.cpp:19, address = 0x0000000140001017
+// CHECK: (lldb) image dump symfile
+// CHECK: Types:
+// CHECK: {{.*}}: Type{0x00010024} , size = 0, compiler_type = {{.*}} int (int, char **)
+// CHECK: Compile units:
+// CHECK: {{.*}}: CompileUnit{0x00000000}, language = "c++", file = '{{.*}}/load-pdb.cpp'
+// CHECK: {{.*}}:   Function{0x08400001}, demangled = main, type = {{.*}}
+// CHECK: {{.*}}:   Block{0x08400001}