[PDB] Check the result of setLoadAddress()

[asmith]

Summary

Change setLoadAddress() to return true or false on failure.

[zturner]

Do you know what would cause this to fail?

[asmith]

No idea :)

It was changed to match the DIA API,
https://docs.microsoft.com/en-us/visualstudio/debugger/debug-interface-access/idiasession-put-loadaddress

[zturner]

Fair enough, was just hoping you knew :)

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

public:
   explicit DIASession(CComPtr<IDiaSession> DiaSession);
 
   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;
+  bool setLoadAddress(uint64_t Address) 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,

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 bool setLoadAddress(uint64_t Address) = 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 {
     return unique_dyn_cast_or_null<T>(getSymbolById(SymbolId));
   }
 

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

public:
   createEnumSymbol(codeview::TypeIndex Index);
 
   std::unique_ptr<IPDBEnumSymbols>
   createTypeEnumerator(codeview::TypeLeafKind Kind);
 
   SymIndexId findSymbolByTypeIndex(codeview::TypeIndex TI);
 
   uint64_t getLoadAddress() const override;
-  void setLoadAddress(uint64_t Address) override;
+  bool setLoadAddress(uint64_t Address) 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,

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

 }
 
 uint64_t DIASession::getLoadAddress() const {
   uint64_t LoadAddress;
   bool success = (S_OK == Session->get_loadAddress(&LoadAddress));
   return (success) ? LoadAddress : 0;
 }
 
-void DIASession::setLoadAddress(uint64_t Address) {
-  Session->put_loadAddress(Address);
+bool DIASession::setLoadAddress(uint64_t Address) {
+  return (S_OK == Session->put_loadAddress(Address));
 }
 
 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);

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

SymIndexId NativeSession::findSymbolByTypeIndex(codeview::TypeIndex Index) {
   assert(I.kind() == codeview::LF_ENUM);
   SymbolCache.emplace_back(llvm::make_unique<NativeEnumSymbol>(*this, Id, I));
   TypeIndexToSymbolId[Index] = Id;
   return Id;
 }
 
 uint64_t NativeSession::getLoadAddress() const { return 0; }
 
-void NativeSession::setLoadAddress(uint64_t Address) {}
+bool NativeSession::setLoadAddress(uint64_t Address) { return false; }
 
 std::unique_ptr<PDBSymbolExe> NativeSession::getGlobalScope() {
   const auto Id = static_cast<SymIndexId>(SymbolCache.size());
   SymbolCache.push_back(llvm::make_unique<NativeExeSymbol>(*this, Id));
   auto RawSymbol = SymbolCache[Id]->clone();
   auto PdbSymbol(PDBSymbol::create(*this, std::move(RawSymbol)));
   std::unique_ptr<PDBSymbolExe> ExeSymbol(
       static_cast<PDBSymbolExe *>(PdbSymbol.release()));

llvm/trunk/unittests/DebugInfo/PDB/PDBApiTest.cpp

 #define MOCK_SYMBOL_ACCESSOR(Func)                                             \
   decltype(std::declval<IPDBRawSymbol>().Func()) Func() const override {       \
     typedef decltype(IPDBRawSymbol::Func()) ReturnType;                        \
     return ReturnType();                                                       \
   }
 
 class MockSession : public IPDBSession {
   uint64_t getLoadAddress() const override { return 0; }
-  void setLoadAddress(uint64_t Address) override {}
+  bool setLoadAddress(uint64_t Address) override { return false; }
   std::unique_ptr<PDBSymbolExe> getGlobalScope() override { return nullptr; }
   std::unique_ptr<PDBSymbol> getSymbolById(uint32_t SymbolId) const override {
     return nullptr;
   }
   std::unique_ptr<IPDBSourceFile>
   getSourceFileById(uint32_t SymbolId) const override {
     return nullptr;
   }