Add an opque payload field to lldb::Type (NFC).

[aprantl]

Summary

This hides the language-specific flags and lets each language define its own fields in the opaquer storage.

[xiaobai]

Thanks for working to make LLDB more language-agnostic!

[aprantl]

Document layout.

[shafik]

I want to see how you end up resolving the comments on payload being a plain integer type in D75626 before looking at this again. Maybe it makes more sense to use a type, the use is pretty clever but perhaps makes for opaque code in some places.

[aprantl]

Address feedback from Pavel and add the payload to the constructor.

[labath]

lldb/include/lldb/Symbol/Type.h

200–201

It doesn't look like this setter is needed, as the single usage has now been changed to a constructor argument. And if this is immutable, then in turn some methods of TypePayloadClang become unneeded (SetIsCompleteObjCClass)

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

63

maybe make this explicit too (and augment it with a encode method to make the usage less weird)?

[aprantl]

Rebase and update based on https://reviews.llvm.org/D75488. It no longer takes a reference, but is a value type instead.

[aprantl]

Remove the obsolete setter in lldb::Type.

[aprantl]

Ping.

[teemperor]

Could you make the uint32_t a typedef? I'm fine with this not being type-safe, but a typedef would at least allow me to search for where this information is used. Grepping/searching for uint32_t isn't a great experience. It would also make this interface more self-documenting.

Beside that LGTM.

lldb/include/lldb/Symbol/Type.h

public:
   // the remaining type scope (namespaces/classes).
   static bool GetTypeScopeAndBasename(const llvm::StringRef& name,
                                       llvm::StringRef &scope,
                                       llvm::StringRef &basename,
                                       lldb::TypeClass &type_class);
   void SetEncodingType(Type *encoding_type) { m_encoding_type = encoding_type; }
 
   uint32_t GetEncodingMask();
-
-  bool IsCompleteObjCClass() { return m_is_complete_objc_class; }
-
-  void SetIsCompleteObjCClass(bool is_complete_objc_class) {
-    m_is_complete_objc_class = is_complete_objc_class;
-  }
+  uint32_t &GetPayload() { return m_payload; }
 
 protected:
   ConstString m_name;
   SymbolFile *m_symbol_file;
   /// The symbol context in which this type is defined.
   SymbolContextScope *m_context;
   Type *m_encoding_type;
   lldb::user_id_t m_encoding_uid;
   EncodingDataType m_encoding_uid_type;
   uint64_t m_byte_size : 63;
   uint64_t m_byte_size_has_value : 1;
   Declaration m_decl;
   CompilerType m_compiler_type;
   ResolveState m_compiler_type_resolve_state;
-  bool m_is_complete_objc_class;
+  /// Language-specific flags.
+  uint32_t m_payload = 0;
 
   Type *GetEncodingType();
 
   bool ResolveCompilerType(ResolveState compiler_type_resolve_state);
 };
 
 // the two classes here are used by the public API as a backend to the SBType
 // and SBTypeList classes

lldb/source/Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.cpp

if (matching_symbols) {
     module_sp->FindTypes(name, exact_match, max_matches, searched_symbol_files,
                          types);
 
     for (uint32_t i = 0; i < types.GetSize(); ++i) {
       TypeSP type_sp(types.GetTypeAtIndex(i));
 
       if (TypeSystemClang::IsObjCObjectOrInterfaceType(
               type_sp->GetForwardCompilerType())) {
-        if (type_sp->IsCompleteObjCClass()) {
+        if (TypePayloadClang(type_sp->GetPayload()).IsCompleteObjCClass()) {
           m_complete_class_cache[name] = type_sp;
           return type_sp;
         }
       }
     }
   }
   m_negative_complete_class_cache.insert(name);
   return TypeSP();

lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

DWARFASTParserClang::ParseStructureLikeDIE(const SymbolContext &sc,
   // parameters in any class methods need it for the clang types for
   // function prototypes.
   LinkDeclContextToDIE(m_ast.GetDeclContextForType(clang_type), die);
   type_sp = std::make_shared<Type>(die.GetID(), dwarf, attrs.name,
                                    attrs.byte_size, nullptr, LLDB_INVALID_UID,
                                    Type::eEncodingIsUID, &attrs.decl,
                                    clang_type, Type::ResolveState::Forward);
 
-  type_sp->SetIsCompleteObjCClass(attrs.is_complete_objc_class);
+  TypePayloadClang(type_sp->GetPayload())
+      .SetIsCompleteObjCClass(attrs.is_complete_objc_class);
 
   // Add our type to the unique type map so we don't end up creating many
   // copies of the same type over and over in the ASTContext for our
   // module
   unique_ast_entry_up->m_type_sp = type_sp;
   unique_ast_entry_up->m_die = die;
   unique_ast_entry_up->m_declaration = unique_decl;
   unique_ast_entry_up->m_byte_size = attrs.byte_size.getValueOr(0);

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.h

 #include "llvm/ADT/SmallVector.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Flags.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Logging.h"
 #include "lldb/lldb-enumerations.h"
 
 class DWARFASTParserClang;
 class PDBASTParser;
 
+namespace clang {
+  class HeaderSearch;
+  class ModuleMap;
+}
+
 namespace lldb_private {
 
 class ClangASTMetadata;
 class ClangASTSource;
 class Declaration;
 
+/// The implementation of lldb::Type's m_payload field for TypeSystemClang.
+class TypePayloadClang {
+  uint32_t &m_payload;
+public:
+  TypePayloadClang(uint32_t &opaque_payload) : m_payload(opaque_payload) {}
+  /// Clang-specific functions. As more of these get added we may want
+  /// to factor this into typesystem-specific subclasses.
+  /// \{
+  static constexpr unsigned ObjCClassBit = 1 << 31;
+  bool IsCompleteObjCClass() { return Flags(m_payload).Test(ObjCClassBit); }
+  void SetIsCompleteObjCClass(bool is_complete_objc_class) {
+    m_payload = is_complete_objc_class ? Flags(m_payload).Set(ObjCClassBit)
+                                       : Flags(m_payload).Clear(ObjCClassBit);
+  }
+  unsigned GetOwningModuleID() { return Flags(m_payload).Clear(ObjCClassBit); }
+  void SetOwningModuleID(unsigned id) {
+    assert(id < ObjCClassBit);
+    bool is_complete = IsCompleteObjCClass();
+    m_payload = id;
+    SetIsCompleteObjCClass(is_complete);
+  }
+  /// \}
+};
+  
 /// A TypeSystem implementation based on Clang.
 ///
 /// This class uses a single clang::ASTContext as the backend for storing
 /// its types and declarations. Every clang::ASTContext should also just have
 /// a single associated TypeSystemClang instance that manages it.
 ///
 /// The clang::ASTContext instance can either be created by TypeSystemClang
 /// itself or it can adopt an existing clang::ASTContext (for example, when

lldb/source/Symbol/Type.cpp

Type::Type(lldb::user_id_t uid, SymbolFile *symbol_file, ConstString name,
            llvm::Optional<uint64_t> byte_size, SymbolContextScope *context,
            user_id_t encoding_uid, EncodingDataType encoding_uid_type,
            const Declaration &decl, const CompilerType &compiler_type,
            ResolveState compiler_type_resolve_state)
     : std::enable_shared_from_this<Type>(), UserID(uid), m_name(name),
       m_symbol_file(symbol_file), m_context(context), m_encoding_type(nullptr),
       m_encoding_uid(encoding_uid), m_encoding_uid_type(encoding_uid_type),
       m_decl(decl), m_compiler_type(compiler_type),
-      m_compiler_type_resolve_state(
-          compiler_type ? compiler_type_resolve_state
-                        : ResolveState::Unresolved),
-      m_is_complete_objc_class(false) {
+      m_compiler_type_resolve_state(compiler_type ? compiler_type_resolve_state
+                                                  : ResolveState::Unresolved) {
   if (byte_size) {
     m_byte_size = *byte_size;
     m_byte_size_has_value = true;
   } else {
     m_byte_size = 0;
     m_byte_size_has_value = false;
   }
 }