[lldb][NFC] Move various constructor definitions from .h to .cpp

[rriddle]

Summary

I ran into issues with linking downstream language plugin to liblldb in
debug builds, hitting link time errors of form:

undefined reference to `vtable for  lldb_private::<Insert LLDB class here>'

Anchoring the vtable to the .cpp files resolved those issues.

[wallace]

lgtm

lldb/include/lldb/Expression/ExpressionVariable.h

 class ExpressionVariable
     : public std::enable_shared_from_this<ExpressionVariable> {
 public:
   // See TypeSystem.h for how to add subclasses to this.
   enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds };
 
   LLVMCastKind getKind() const { return m_kind; }
 
-  ExpressionVariable(LLVMCastKind kind) : m_flags(0), m_kind(kind) {}
-
+  ExpressionVariable(LLVMCastKind kind);
   virtual ~ExpressionVariable();
 
   std::optional<uint64_t> GetByteSize() { return m_frozen_sp->GetByteSize(); }
 
   ConstString GetName() { return m_frozen_sp->GetName(); }
 
   lldb::ValueObjectSP GetValueObject() { return m_frozen_sp; }
 

 
 class PersistentExpressionState : public ExpressionVariableList {
 public:
   // See TypeSystem.h for how to add subclasses to this.
   enum LLVMCastKind { eKindClang, eKindSwift, eKindGo, kNumKinds };
 
   LLVMCastKind getKind() const { return m_kind; }
 
-  PersistentExpressionState(LLVMCastKind kind) : m_kind(kind) {}
-
+  PersistentExpressionState(LLVMCastKind kind);
   virtual ~PersistentExpressionState();
 
   virtual lldb::ExpressionVariableSP
   CreatePersistentVariable(const lldb::ValueObjectSP &valobj_sp) = 0;
 
   virtual lldb::ExpressionVariableSP
   CreatePersistentVariable(ExecutionContextScope *exe_scope,
                            ConstString name, const CompilerType &type,

lldb/include/lldb/Expression/Materializer.h

public:
   typedef std::shared_ptr<Dematerializer> DematerializerSP;
   typedef std::weak_ptr<Dematerializer> DematerializerWP;
 
   DematerializerSP Materialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
                                lldb::addr_t process_address, Status &err);
 
   class PersistentVariableDelegate {
   public:
+    PersistentVariableDelegate();
     virtual ~PersistentVariableDelegate();
     virtual ConstString GetName() = 0;
     virtual void DidDematerialize(lldb::ExpressionVariableSP &variable) = 0;
   };
 
   uint32_t
   AddPersistentVariable(lldb::ExpressionVariableSP &persistent_variable_sp,
                         PersistentVariableDelegate *delegate, Status &err);

lldb/include/lldb/Symbol/TypeSystem.h

 ///
 /// \see lldb_private::CompilerType
 /// \see lldb_private::CompilerDecl
 /// \see lldb_private::CompilerDeclContext
 class TypeSystem : public PluginInterface,
                    public std::enable_shared_from_this<TypeSystem> {
 public:
   // Constructors and Destructors
+  TypeSystem();
   ~TypeSystem() override;
 
   // LLVM RTTI support
   virtual bool isA(const void *ClassID) const = 0;
 
   static lldb::TypeSystemSP CreateInstance(lldb::LanguageType language,
                                            Module *module);
 

lldb/source/Expression/ExpressionVariable.cpp

 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include <optional>
 
 using namespace lldb_private;
 
+ExpressionVariable::ExpressionVariable(LLVMCastKind kind)
+    : m_flags(0), m_kind(kind) {}
 ExpressionVariable::~ExpressionVariable() = default;
 
 uint8_t *ExpressionVariable::GetValueBytes() {
   std::optional<uint64_t> byte_size = m_frozen_sp->GetByteSize();
   if (byte_size && *byte_size) {
     if (m_frozen_sp->GetDataExtractor().GetByteSize() < *byte_size) {
       m_frozen_sp->GetValue().ResizeData(*byte_size);
       m_frozen_sp->GetValue().GetData(m_frozen_sp->GetDataExtractor());
     }
     return const_cast<uint8_t *>(
         m_frozen_sp->GetDataExtractor().GetDataStart());
   }
   return nullptr;
 }
 
+PersistentExpressionState::PersistentExpressionState(LLVMCastKind kind)
+    : m_kind(kind) {}
 PersistentExpressionState::~PersistentExpressionState() = default;
 
 lldb::addr_t PersistentExpressionState::LookupSymbol(ConstString name) {
   SymbolMap::iterator si = m_symbol_map.find(name.GetCString());
 
   if (si != m_symbol_map.end())
     return si->second;
   else

lldb/source/Expression/Materializer.cpp

for (EntityUP &entity_up : m_materializer->m_entities) {
     entity_up->Wipe(*m_map, m_process_address);
   }
 
   m_materializer = nullptr;
   m_map = nullptr;
   m_process_address = LLDB_INVALID_ADDRESS;
 }
 
+Materializer::PersistentVariableDelegate::PersistentVariableDelegate() =
+    default;
 Materializer::PersistentVariableDelegate::~PersistentVariableDelegate() =
     default;

lldb/source/Symbol/TypeSystem.cpp

std::optional<LanguageType> LanguageSet::GetSingularLanguage() {
   return {};
 }
 
 void LanguageSet::Insert(LanguageType language) { bitvector.set(language); }
 size_t LanguageSet::Size() const { return bitvector.count(); }
 bool LanguageSet::Empty() const { return bitvector.none(); }
 bool LanguageSet::operator[](unsigned i) const { return bitvector[i]; }
 
+TypeSystem::TypeSystem() = default;
 TypeSystem::~TypeSystem() = default;
 
 static TypeSystemSP CreateInstanceHelper(lldb::LanguageType language,
                                          Module *module, Target *target) {
   uint32_t i = 0;
   TypeSystemCreateInstance create_callback;
   while ((create_callback = PluginManager::GetTypeSystemCreateCallbackAtIndex(
               i++)) != nullptr) {