Make CompilerType safe

When a process gets restarted TypeSystem objects associated with it
may get deleted, and any CompilerType objects holding on to a
reference to that type system are a use-after-free in waiting. Because
of the SBAPI, we don't have tight control over where CompilerTypes go
and when they are used. This is particularly a problem in the Swift
plugin, where the scratch TypeSystem can be restarted while the
process is still running. The Swift plugin has a lock to prevent
abuse, but where there's a lock there can be bugs.

This patch changes CompilerType to store a std::weak_ptr<TypeSystem>.
Most of the std::weak_ptr<TypeSystem>* uglyness is hidden by
introducing a wrapper class CompilerType::WrappedTypeSystem that has a
dyn_cast_or_null() method. The only sites that need to know about the
weak pointer implementation detail are the ones that deal with
creating TypeSystems.

rdar://101505232

Differential Revision: https://reviews.llvm.org/D136650

1 files changed, 23 insertions, 21 deletions

diff --git a/lldb/source/API/SBModule.cpp b/lldb/source/API/SBModule.cpp
index c4e876eb15de..e7c2b451eb9d 100644
--- a/lldb/source/API/SBModule.cpp
+++ b/lldb/source/API/SBModule.cpp
@@ -436,26 +436,28 @@ lldb::SBValue SBModule::FindFirstGlobalVariable(lldb::SBTarget &target,
 lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
   LLDB_INSTRUMENT_VA(this, name_cstr);
 
-  SBType sb_type;
   ModuleSP module_sp(GetSP());
-  if (name_cstr && module_sp) {
-    SymbolContext sc;
-    const bool exact_match = false;
-    ConstString name(name_cstr);
+  if (!name_cstr || !module_sp)
+    return {};
+  SymbolContext sc;
+  const bool exact_match = false;
+  ConstString name(name_cstr);
 
-    sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
+  SBType sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
 
-    if (!sb_type.IsValid()) {
-      auto type_system_or_err =
-          module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
-      if (auto err = type_system_or_err.takeError()) {
-        llvm::consumeError(std::move(err));
-        return SBType();
-      }
-      sb_type = SBType(type_system_or_err->GetBuiltinTypeByName(name));
-    }
+  if (sb_type.IsValid())
+    return sb_type;
+
+  auto type_system_or_err = module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
+  if (auto err = type_system_or_err.takeError()) {
+    llvm::consumeError(std::move(err));
+    return {};
   }
-  return sb_type;
+
+  if (auto ts = *type_system_or_err)
+    return SBType(ts->GetBuiltinTypeByName(name));
+
+  return {};
 }
 
 lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
@@ -468,7 +470,8 @@ lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
     if (auto err = type_system_or_err.takeError()) {
       llvm::consumeError(std::move(err));
     } else {
-      return SBType(type_system_or_err->GetBasicTypeFromAST(type));
+      if (auto ts = *type_system_or_err)
+        return SBType(ts->GetBasicTypeFromAST(type));              
     }
   }
   return SBType();
@@ -494,10 +497,9 @@ lldb::SBTypeList SBModule::FindTypes(const char *type) {
       if (auto err = type_system_or_err.takeError()) {
         llvm::consumeError(std::move(err));
       } else {
-        CompilerType compiler_type =
-            type_system_or_err->GetBuiltinTypeByName(name);
-        if (compiler_type)
-          retval.Append(SBType(compiler_type));
+        if (auto ts = *type_system_or_err)
+          if (CompilerType compiler_type = ts->GetBuiltinTypeByName(name))
+            retval.Append(SBType(compiler_type));
       }
     } else {
       for (size_t idx = 0; idx < type_list.GetSize(); idx++) {