Implement some methods for NativeRawSymbol

[amccarth]

Summary

This allows the ability to call IPDBSession::getGlobalScope with a NativeSession and
to then query it for some basic fields via the PDB's InfoStream.

Note that the symbols now have non-const references back to the Session so that
NativeRawSymbol can access the PDBFile through the Session.

[zturner]

llvm/include/llvm/DebugInfo/PDB/Native/NativeSession.h

24–26 ↗

(On Diff #89576)

Is the Path here necessary? The PDBFile` class is constructed with a Path, and you can query it via getFilePath().

llvm/lib/DebugInfo/PDB/Native/NativeRawSymbol.cpp

70 ↗

(On Diff #89576)

If it fails, then IS is going to have an Error in it. And if it does, this is going to assert / crash if you don't explicitly handle the error. Usually I do something like this:

if (IS)
  return IS->getAge();
return IS.takeError();

But in this case you have nowhere to propagate the error to, so instead you can write consumeError(IS.takeError()); return 0;

Granted, silently throwing away errors is not ideal, but I don't see any solution to this unless you verify that it exists when you construct the NativeRawSymbol.

337 ↗

(On Diff #89576)

Same problem here.

[amccarth]

Thanks for the tips on how to handle the Expected. From the description, I had the impression that it was only necessary to check for the error.

llvm/include/llvm/DebugInfo/PDB/Native/NativeSession.h

24–26 ↗

(On Diff #89576)

Now that I've re-based I see it. Done.

[amccarth]

Addressed zturner's comments and rebased.

llvm/trunk/include/llvm/DebugInfo/PDB/DIA/DIASession.h

public:
 
   static Error createFromPdb(StringRef Path,
                              std::unique_ptr<IPDBSession> &Session);
   static Error createFromExe(StringRef Path,
                              std::unique_ptr<IPDBSession> &Session);
 
   uint64_t getLoadAddress() const override;
   void setLoadAddress(uint64_t Address) override;
-  std::unique_ptr<PDBSymbolExe> getGlobalScope() const override;
+  std::unique_ptr<PDBSymbolExe> getGlobalScope() override;
   std::unique_ptr<PDBSymbol> getSymbolById(uint32_t SymbolId) const override;
 
   std::unique_ptr<PDBSymbol>
   findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override;
 
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
                   const IPDBSourceFile &File) const override;

llvm/trunk/include/llvm/DebugInfo/PDB/IPDBSession.h

 /// IPDBSession defines an interface used to provide a context for querying
 /// debug information from a debug data source (for example, a PDB).
 class IPDBSession {
 public:
   virtual ~IPDBSession();
 
   virtual uint64_t getLoadAddress() const = 0;
   virtual void setLoadAddress(uint64_t Address) = 0;
-  virtual std::unique_ptr<PDBSymbolExe> getGlobalScope() const = 0;
+  virtual std::unique_ptr<PDBSymbolExe> getGlobalScope() = 0;
   virtual std::unique_ptr<PDBSymbol> getSymbolById(uint32_t SymbolId) const = 0;
 
   template <typename T>
   std::unique_ptr<T> getConcreteSymbolById(uint32_t SymbolId) const {
     auto Symbol(getSymbolById(SymbolId));
     if (!Symbol)
       return nullptr;
 

llvm/trunk/include/llvm/DebugInfo/PDB/Native/NativeRawSymbol.h

 
 namespace llvm {
 namespace pdb {
 
 class NativeSession;
 
 class NativeRawSymbol : public IPDBRawSymbol {
 public:
-  explicit NativeRawSymbol(const NativeSession &PDBSession);
+  explicit NativeRawSymbol(NativeSession &PDBSession);
 
   void dump(raw_ostream &OS, int Indent) const override;
 
   std::unique_ptr<IPDBEnumSymbols>
     findChildren(PDB_SymType Type) const override;
   std::unique_ptr<IPDBEnumSymbols>
     findChildren(PDB_SymType Type, StringRef Name,
       PDB_NameSearchFlags Flags) const override;
public:
   bool isUnreached() const override;
   bool isValueUdt() const override;
   bool isVirtual() const override;
   bool isVirtualBaseClass() const override;
   bool isVirtualInheritance() const override;
   bool isVolatileType() const override;
   bool wasInlined() const override;
   std::string getUnused() const override;
+
+private:
+  NativeSession &Session;
 };
 
 }
 }
 
 #endif

llvm/trunk/include/llvm/DebugInfo/PDB/Native/NativeSession.h

public:
 
   static Error createFromPdb(StringRef Path,
                              std::unique_ptr<IPDBSession> &Session);
   static Error createFromExe(StringRef Path,
                              std::unique_ptr<IPDBSession> &Session);
 
   uint64_t getLoadAddress() const override;
   void setLoadAddress(uint64_t Address) override;
-  std::unique_ptr<PDBSymbolExe> getGlobalScope() const override;
+  std::unique_ptr<PDBSymbolExe> getGlobalScope() override;
   std::unique_ptr<PDBSymbol> getSymbolById(uint32_t SymbolId) const override;
 
   std::unique_ptr<PDBSymbol>
   findSymbolByAddress(uint64_t Address, PDB_SymType Type) const override;
 
   std::unique_ptr<IPDBEnumLineNumbers>
   findLineNumbers(const PDBSymbolCompiland &Compiland,
                   const IPDBSourceFile &File) const override;

llvm/trunk/lib/DebugInfo/PDB/DIA/DIASession.cpp

uint64_t DIASession::getLoadAddress() const {
   bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
   return (success) ? LoadAddress : 0;
 }
 
 void DIASession::setLoadAddress(uint64_t Address) {
   Session->put_loadAddress(Address);
 }
 
-std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() const {
+std::unique_ptr<PDBSymbolExe> DIASession::getGlobalScope() {
   CComPtr<IDiaSymbol> GlobalScope;
   if (S_OK != Session->get_globalScope(&GlobalScope))
     return nullptr;
 
   auto RawSymbol = llvm::make_unique<DIARawSymbol>(*this, GlobalScope);
   auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
   std::unique_ptr<PDBSymbolExe> ExeSymbol(
       static_cast<PDBSymbolExe *>(PdbSymbol.release()));

llvm/trunk/lib/DebugInfo/PDB/Native/NativeRawSymbol.cpp

 //===- NativeRawSymbol.cpp - Native implementation of IPDBRawSymbol -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/DebugInfo/PDB/Native/InfoStream.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
+#include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/PDBExtras.h"
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::pdb;
 
-NativeRawSymbol::NativeRawSymbol(const NativeSession &PDBSession) {}
+NativeRawSymbol::NativeRawSymbol(NativeSession &PDBSession)
+  : Session(PDBSession) {}
 
 void NativeRawSymbol::dump(raw_ostream &OS, int Indent) const {}
 
 std::unique_ptr<IPDBEnumSymbols>
 NativeRawSymbol::findChildren(PDB_SymType Type) const {
   return nullptr;
 }
 
uint32_t NativeRawSymbol::getAddressOffset() const {
   return 0;
 }
 
 uint32_t NativeRawSymbol::getAddressSection() const {
   return 0;
 }
 
 uint32_t NativeRawSymbol::getAge() const {
+  auto &File = Session.getPDBFile();
+  auto IS = File.getPDBInfoStream();
+  if (IS)
+    return IS->getAge();
+  consumeError(IS.takeError());
   return 0;
 }
 
 uint32_t NativeRawSymbol::getArrayIndexTypeId() const {
   return 0;
 }
 
 void NativeRawSymbol::getBackEndVersion(VersionInfo &Version) const {
uint32_t NativeRawSymbol::getStride() const {
   return 0;
 }
 
 uint32_t NativeRawSymbol::getSubTypeId() const {
   return 0;
 }
 
 std::string NativeRawSymbol::getSymbolsFileName() const {
-  return 0;
+  return Session.getPDBFile().getFilePath();
 }
 
 uint32_t NativeRawSymbol::getSymIndexId() const {
   return 0;
 }
 
 uint32_t NativeRawSymbol::getTargetOffset() const {
   return 0;
PDB_DataKind NativeRawSymbol::getDataKind() const {
   return PDB_DataKind::Unknown;
 }
 
 PDB_SymType NativeRawSymbol::getSymTag() const {
   return PDB_SymType::None;
 }
 
 PDB_UniqueId NativeRawSymbol::getGuid() const {
-  return {{0}};
+  auto &File = Session.getPDBFile();
+  auto IS = File.getPDBInfoStream();
+  if (IS)
+    return IS->getGuid();
+  consumeError(IS.takeError());
+  return PDB_UniqueId{{0}};
 }
 
 int32_t NativeRawSymbol::getOffset() const {
   return 0;
 }
 
 int32_t NativeRawSymbol::getThisAdjust() const {
   return 0;

llvm/trunk/lib/DebugInfo/PDB/Native/NativeSession.cpp

 //===- NativeSession.cpp - Native implementation of IPDBSession -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/PDB/Native/NativeSession.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/DebugInfo/MSF/ByteStream.h"
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
+#include "llvm/DebugInfo/PDB/Native/NativeRawSymbol.h"
 #include "llvm/DebugInfo/PDB/Native/PDBFile.h"
 #include "llvm/DebugInfo/PDB/Native/RawError.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolCompiland.h"
 #include "llvm/DebugInfo/PDB/PDBSymbolExe.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/MemoryBuffer.h"
Error NativeSession::createFromExe(StringRef Path,
                                    std::unique_ptr<IPDBSession> &Session) {
   return make_error<RawError>(raw_error_code::feature_unsupported);
 }
 
 uint64_t NativeSession::getLoadAddress() const { return 0; }
 
 void NativeSession::setLoadAddress(uint64_t Address) {}
 
-std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() const {
-  return nullptr;
+std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
+  auto RawSymbol = llvm::make_unique<NativeRawSymbol>(*this);
+  auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
+  std::unique_ptr<PDBSymbolExe> ExeSymbol(
+    static_cast<PDBSymbolExe *>(PdbSymbol.release()));
+  return ExeSymbol;
 }
 
 std::unique_ptr<PDBSymbol>
 NativeSession::getSymbolById(uint32_t SymbolId) const {
   return nullptr;
 }
 
 std::unique_ptr<PDBSymbol>