Add the ability to see when a type in incomplete.

[clayborg]

Summary

-flimit-debug-info and other compiler options might end up removing debug info that is needed for debugging. LLDB marks these types as being forcefully completed in the metadata in the TypeSystem. These types should have been complete in the debug info but were not because the compiler omitted them to save space. When we can't find a suitable replacement for the type, we should let the user know that these types are incomplete to indicate there was an issue instead of just showing nothing for a type.

The solution is to display presented in this patch is to display "<incomplete type>" as the summary for any incomplete types. If there is a summary string or function that is provided for a type, but the type is currently forcefully completed, the installed summary will be ignored and we will display "<incomplete type>". This patch also exposes the ability to ask a SBType if it was forcefully completed with:

bool SBType::IsTypeForcefullyCompleted();

This will allow the user interface for a debugger to also detect this issue and possibly mark the variable display up on some way to indicate to the user the type is incomplete.

To show how this is diplayed, we can look at the existing output first for the example source file from the file: lldb/test/API/functionalities/limit-debug-info/main.cpp

(lldb) frame variable inherits_from_one inherits_from_two one_as_member two_as_member array_of_one array_of_two shadowed_one
(InheritsFromOne) ::inherits_from_one = (member = 47)
(InheritsFromTwo) ::inherits_from_two = (member = 47)
(OneAsMember) ::one_as_member = (one = member::One @ 0x0000000100008028, member = 47)
(TwoAsMember) ::two_as_member = (two = member::Two @ 0x0000000100008040, member = 47)
(array::One [3]) ::array_of_one = ([0] = array::One @ 0x0000000100008068, [1] = array::One @ 0x0000000100008069, [2] = array::One @ 0x000000010000806a)
(array::Two [3]) ::array_of_two = ([0] = array::Two @ 0x0000000100008098, [1] = array::Two @ 0x0000000100008099, [2] = array::Two @ 0x000000010000809a)
(ShadowedOne) ::shadowed_one = (member = 47)
(lldb) frame variable --show-types inherits_from_one inherits_from_two one_as_member two_as_member array_of_one array_of_two shadowed_one
(InheritsFromOne) ::inherits_from_one = {
  (int) member = 47
}
(InheritsFromTwo) ::inherits_from_two = {
  (int) member = 47
}
(OneAsMember) ::one_as_member = {
  (member::One) one = {}
  (int) member = 47
}
(TwoAsMember) ::two_as_member = {
  (member::Two) two = {}
  (int) member = 47
}
(array::One [3]) ::array_of_one = {
  (array::One) [0] = {}
  (array::One) [1] = {}
  (array::One) [2] = {}
}
(array::Two [3]) ::array_of_two = {
  (array::Two) [0] = {}
  (array::Two) [1] = {}
  (array::Two) [2] = {}
}
(ShadowedOne) ::shadowed_one = {
  (int) member = 47
}

With this patch in place we can now see any classes that were forcefully completed to let us know that we are missing information:

(lldb) frame variable inherits_from_one inherits_from_two one_as_member two_as_member array_of_one array_of_two shadowed_one
(InheritsFromOne) ::inherits_from_one = (One = <incomplete type>, member = 47)
(InheritsFromTwo) ::inherits_from_two = (Two = <incomplete type>, member = 47)
(OneAsMember) ::one_as_member = (one = <incomplete type>, member = 47)
(TwoAsMember) ::two_as_member = (two = <incomplete type>, member = 47)
(array::One[3]) ::array_of_one = ([0] = <incomplete type>, [1] = <incomplete type>, [2] = <incomplete type>)
(array::Two[3]) ::array_of_two = ([0] = <incomplete type>, [1] = <incomplete type>, [2] = <incomplete type>)
(ShadowedOne) ::shadowed_one = (func_shadow::One = <incomplete type>, member = 47)
(lldb) frame variable --show-types inherits_from_one inherits_from_two one_as_member two_as_member array_of_one array_of_two shadowed_one
(InheritsFromOne) ::inherits_from_one = {
  (One) One = <incomplete type> {}
  (int) member = 47
}
(InheritsFromTwo) ::inherits_from_two = {
  (Two) Two = <incomplete type> {}
  (int) member = 47
}
(OneAsMember) ::one_as_member = {
  (member::One) one = <incomplete type> {}
  (int) member = 47
}
(TwoAsMember) ::two_as_member = {
  (member::Two) two = <incomplete type> {}
  (int) member = 47
}
(array::One[3]) ::array_of_one = {
  (array::One) [0] = <incomplete type> {}
  (array::One) [1] = <incomplete type> {}
  (array::One) [2] = <incomplete type> {}
}
(array::Two[3]) ::array_of_two = {
  (array::Two) [0] = <incomplete type> {}
  (array::Two) [1] = <incomplete type> {}
  (array::Two) [2] = <incomplete type> {}
}
(ShadowedOne) ::shadowed_one = {
  (func_shadow::One) func_shadow::One = <incomplete type> {}
  (int) member = 47
}

[clayborg]

Forgot to mention that this patch will force any empty base classes that were forcefully completed to show up in the variable display so the user can know that the type was forcefully completed.

[clayborg]

We can see this in action with the before "var" output of:

(InheritsFromOne) ::inherits_from_one = {
  (int) member = 47
}

And after, we see the "One" class definition and we can see that it is incomplete:

(InheritsFromOne) ::inherits_from_one = {
  (One) One = <incomplete type> {}
  (int) member = 47
}

[clayborg]

The next step for this is to modify the ValueObject::MaybeCalculateCompleteType() to see if we get a type that has been forcefully completed and if it has, replace it with the real type. But that will require that Module::FindFirstType() works reliably and it currently doesn't (fix for this issue is in this patch: https://reviews.llvm.org/D137900).

[aprantl]

lldb/include/lldb/API/SBType.h

212

a complete? (missing word)

223

Could you replace all instances of "we" with something more concrete? It sounds like this paragraph really describes behaviors of TypeSystemClang?

237

Why not IsIncomplete()?

[aprantl]

Generally, I think this can be useful information. I don't have any better suggestion, but I'd like to ask the room if we think that <incomplete type> is a good message for the end users. (Forward-declared type, type missing from debug info, ...?)

lldb/source/Core/ValueObject.cpp

601

I don't ha

[clayborg]

lldb/include/lldb/API/SBType.h

212

yep, will remove the "a" here..

223

It is describing what -flimit-debug-info does, so yes, this is very clang specific. But right now we are showing these omitted types to the user as if they are fine, and they are not, so the user and or UI can and should convey this somehow. Not a great user experience when someone enables -flimit-debug-info, not on purpose as this is the default on non darwin targets, and they get a subpar debugging experience. We run into this all the time with linux and Android and the users think the debugger doesn't know how to show variables, so we need to let them know what is going on somehow.

That being said, I can probably make this paragraph a lot simpler. Open to suggestions.

237

We already have IsTypeComplete() above, which indicates that something is a forward declaration. The IsTypeComplete() will return true for these forcefully completed types since they appear to be complete. I am open to suggestions on better naming, I was just forwarding our internal function names, but for the API a better name might make more sense. I can't think of any off hand.

lldb/source/Core/ValueObject.cpp

601

I am open to suggestions on what people want this string to be.

[clayborg]

Changed the API comment describing the SBType::IsTypeForcefullyCompleted().

[clayborg]

In D138259#3938841, @aprantl wrote:

Generally, I think this can be useful information. I don't have any better suggestion, but I'd like to ask the room if we think that <incomplete type> is a good message for the end users. (Forward-declared type, type missing from debug info, ...?)

"forward-declared type" might sound like it is normal for this type to be forward declared. "type missing from debug info" is better as it conveys exactly what is going on.

[labath]

I have a somewhat high level question. Do we actually want (SB)Type::IsTypeComplete to return true for these kinds of types?

For clang's benefit, we have to pretend that the AST objects are complete (and empty), but we're not similarly restricted in our own representations of those types, so we could theoretically just answer false here (and possibly have some additional method to indicate that the type is strange in some way).

[clayborg]

In D138259#3940689, @labath wrote:

I have a somewhat high level question. Do we actually want (SB)Type::IsTypeComplete to return true for these kinds of types?

For clang's benefit, we have to pretend that the AST objects are complete (and empty), but we're not similarly restricted in our own representations of those types, so we could theoretically just answer false here (and possibly have some additional method to indicate that the type is strange in some way).

If we have a forward declaration to a type, it is ok for that type to be incomplete. So for a variable like "struct Foo; Foo *foo = ...", it is ok for "Foo" to not be complete here. But if we have "Foo foo = ...;" then it isn't ok for Foo to not be complete. We need to tell the difference between "a type is incomplete and it is ok" and "a type should be complete but isn't and you are losing information that should have been available for you to debug".

[labath]

In D138259#3941431, @clayborg wrote:

"a type should be complete but isn't and you are losing information that should have been available for you to debug".

I agree, but there are still two (or more) ways to communicate that information.

1. "this type is complete" + "actually, I'm just missing the debug info and pretending it's complete"
2. "this type is incomplete" + "it is incomplete because I am missing its debug info"

My question is which method would be more useful to the user.

[clayborg]

In D138259#3941465, @labath wrote:

In D138259#3941431, @clayborg wrote:

"a type should be complete but isn't and you are losing information that should have been available for you to debug".

I agree, but there are still two (or more) ways to communicate that information.

1. "this type is complete" + "actually, I'm just missing the debug info and pretending it's complete"
2. "this type is incomplete" + "it is incomplete because I am missing its debug info"

My question is which method would be more useful to the user.

Gotcha. We could change "bool SBType::IsTypeComplete()" to return false, and then add a new:

bool SBType::ShouldBeComplete();

That would return true if IsTypeComplete() returned false because it was forcefully completed.

The main issue with doing it this way is if you ask if type if it is complete by calling "bool SBType::IsTypeComplete()", you will force the type to complete itself to be able to answer the question. Right now if you have a GUI debugger and you just show the top level variables, we never need to complete any of the types unless the user turns them open in the GUI. The main reason for this API in SBType is for GUI debuggers to be able to indicate there is a problem to the user, but we don't want it to cause the debugger to realize types when it doesn't need to. The current IsTypeForcefullyCompleted() won't need to complete the type in order to figure out the result.

[yinghuitan]

lldb/source/Core/ValueObject.cpp

600

Is this shown in lldb-vscode? If so, can I suggest we add a VSCode test for it if not too much work?

[yinghuitan]

Also, do you have any plan to record this happening in statistics dump so that our telemetry can report it?

[clayborg]

In D138259#3942246, @yinghuitan wrote:

Also, do you have any plan to record this happening in statistics dump so that our telemetry can report it?

I do, that will be a separate patch I will make once this patch is in.

lldb/source/Core/ValueObject.cpp

600

It will show up as the summary, no need to duplicate the functionality in another location

[labath]

In D138259#3941859, @clayborg wrote:

In D138259#3941465, @labath wrote:

In D138259#3941431, @clayborg wrote:

"a type should be complete but isn't and you are losing information that should have been available for you to debug".

I agree, but there are still two (or more) ways to communicate that information.

1. "this type is complete" + "actually, I'm just missing the debug info and pretending it's complete"
2. "this type is incomplete" + "it is incomplete because I am missing its debug info"

My question is which method would be more useful to the user.

Gotcha. We could change "bool SBType::IsTypeComplete()" to return false, and then add a new:

bool SBType::ShouldBeComplete();

That would return true if IsTypeComplete() returned false because it was forcefully completed.

That is the expected behavior, but we wouldn't need to implement it that way. We could still implement it by calling the "is forcefully completed" metadata function, and so it wouldn't force the completion of the type. So a true return value would mean that the type has been forcefully completed, while a return value of false would mean that the type is complete (not just pretend-complete) or the completion of the type hasn't been attempted yet.

Note that I'm not saying that this is how it needs to be implemented. However, I think its worth thinking about this, given that we're adding a new public interface and all. I think it comes down to the question of which situation would be more/less confusing to the (SB) user

• querying a member/base class of an object and finding that it's incomplete (even though that is not possible in regular c++)
• querying a member/base class of an object and finding that it's empty (even though the truth is that we just don't know what it contains.)

[clayborg]

In D138259#3943739, @labath wrote:

In D138259#3941859, @clayborg wrote:

In D138259#3941465, @labath wrote:

In D138259#3941431, @clayborg wrote:

"a type should be complete but isn't and you are losing information that should have been available for you to debug".

I agree, but there are still two (or more) ways to communicate that information.

1. "this type is complete" + "actually, I'm just missing the debug info and pretending it's complete"
2. "this type is incomplete" + "it is incomplete because I am missing its debug info"

My question is which method would be more useful to the user.

Gotcha. We could change "bool SBType::IsTypeComplete()" to return false, and then add a new:

bool SBType::ShouldBeComplete();

That would return true if IsTypeComplete() returned false because it was forcefully completed.

That is the expected behavior, but we wouldn't need to implement it that way. We could still implement it by calling the "is forcefully completed" metadata function, and so it wouldn't force the completion of the type. So a true return value would mean that the type has been forcefully completed, while a return value of false would mean that the type is complete (not just pretend-complete) or the completion of the type hasn't been attempted yet.

The current SBType::IsTypeComplete() will complete the type in order to figure out if it is actually complete. So although we can shortcut this for forcefully completed types, it wouldn't work for other types.

Note that I'm not saying that this is how it needs to be implemented. However, I think its worth thinking about this, given that we're adding a new public interface and all. I think it comes down to the question of which situation would be more/less confusing to the (SB) user

• querying a member/base class of an object and finding that it's incomplete (even though that is not possible in regular c++)
• querying a member/base class of an object and finding that it's empty (even though the truth is that we just don't know what it contains.)

Why don't I remove this API change from this patch to allow the patch to get into open source and we can revisit if we need to since we don't have any clients for this right now. But I do think it is a good idea to change the SBTType::IsTypeComplete() to return false for forcefully completed types, so I will make that change and test it.

[clayborg]

Remove SBType::IsTypeForcefullyCompleted() for now. Change SBType::IsTypeComplete() to return false for forcefully completed types. I did this only in the public API, not internally since we have the CompilerType::IsForcefullyCompleted() available and internal code can deal with this special case if needed.

[labath]

Okay, looks good to me.

[mstorsjo]

This seems to have caused build errors with GCC:

../tools/lldb/source/Symbol/CompilerType.cpp: In member function ‘bool lldb_private::CompilerType::IsForcefullyCompleted() const’:
../tools/lldb/source/Symbol/CompilerType.cpp:99:25: error: base operand of ‘->’ has non-pointer type ‘const TypeSystemWP’ {aka ‘const std::weak_ptr<lldb_private::TypeSystem>’}
   99 |     return m_type_system->IsForcefullyCompleted(m_type);
      |                         ^~

Any clues about what’s missing?

[clayborg]

In D138259#3947410, @mstorsjo wrote:

This seems to have caused build errors with GCC:

../tools/lldb/source/Symbol/CompilerType.cpp: In member function ‘bool lldb_private::CompilerType::IsForcefullyCompleted() const’:
../tools/lldb/source/Symbol/CompilerType.cpp:99:25: error: base operand of ‘->’ has non-pointer type ‘const TypeSystemWP’ {aka ‘const std::weak_ptr<lldb_private::TypeSystem>’}
   99 |     return m_type_system->IsForcefullyCompleted(m_type);
      |                         ^~

Any clues about what’s missing?

Someone fixed the build issue for me! Things should be working

lldb/bindings/interface/SBType.i

public:
     * Objective-C: Follows the same behavior as C for struct types. Objective-C
       classes are considered complete unless they were only forward declared via
       ``@class ClassName`` in the type's `SBTarget`/`SBModule`. Otherwise
       returns true.
     ") IsTypeComplete;
     bool
     IsTypeComplete ();
 
+    bool
+    IsTypeForcefullyCompleted ();
+
     %feature("docstring",
     "Returns the `TypeFlags` values for this type.
 
     See the respective `TypeFlags` values for what values can be set. Returns an
     integer in which each `TypeFlags` value is represented by a bit. Specific
     flags can be checked via Python's bitwise operators. For example, the
     `eTypeIsInteger` flag can be checked like this:
 

lldb/include/lldb/API/SBType.h

public:
   const char *GetName();
 
   const char *GetDisplayTypeName();
 
   lldb::TypeClass GetTypeClass();
 
   bool IsTypeComplete();
 
+  /// Return true if this type should have been complete in the debug
+  /// information but it the full definition was omitted.
+  ///
+  /// Returns true for types that were incomplete in the debug information but
+  /// should have been complete. When the debugger constructs types, we must
+  /// have enough information to reconstruct a type. When we need a complete
+  /// type, such as when a class A inherits from class B, we need a full
+  /// definition for class B so that we can construct class A. Another instance
+  /// is we have a variable that is an instance of a type (not just a pointer or
+  /// reference) we must also have the full definition of the class in order to
+  /// display the variable to the user. Compiler options (-flimit-debug-info)
+  /// can cause the compiler to not emit full debug information for some types
+  /// in order to reduce debug information size. The assumption is the full
+  /// definition of this type will be available in some of the debug information
+  /// in a debug session, possibly even in another executable or shared
+  /// library's debug information. If a full definition for a type was required
+  /// but we can't find a full definition, this function will return true. Type
+  /// objects may return true to SBType::IsTypeComplete() as the types were
+  /// internally made complete to allow the type that depends on this type to be
+  /// created, but this function indicates that debug information should have
+  /// had a complete definition for the type, but we were not able to find one.
+  bool IsTypeForcefullyCompleted();
+
   uint32_t GetTypeFlags();
 
   bool GetDescription(lldb::SBStream &description,
                       lldb::DescriptionLevel description_level);
 
   lldb::SBType &operator=(const lldb::SBType &rhs);
 
   bool operator==(lldb::SBType &rhs);
 
   bool operator!=(lldb::SBType &rhs);
 
 protected:
   lldb_private::TypeImpl &ref();
 
   const lldb_private::TypeImpl &ref() const;

lldb/include/lldb/Symbol/CompilerType.h

public:
   bool IsVoidType() const;
   /// \}
 
   /// Type Completion.
   /// \{
   bool GetCompleteType() const;
   /// \}
 
+  bool IsForcefullyCompleted() const;
+
   /// AST related queries.
   /// \{
   size_t GetPointerByteSize() const;
   /// \}
 
   /// Accessors.
   /// \{
   TypeSystem *GetTypeSystem() const { return m_type_system; }

lldb/include/lldb/Symbol/TypeSystem.h

#endif
 
   // TypeSystems can support more than one language
   virtual bool SupportsLanguage(lldb::LanguageType language) = 0;
 
   // Type Completion
 
   virtual bool GetCompleteType(lldb::opaque_compiler_type_t type) = 0;
 
+  virtual bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type) {
+    return false;
+  }
+
   // AST related queries
 
   virtual uint32_t GetPointerByteSize() = 0;
 
   // Accessors
 
   virtual ConstString GetTypeName(lldb::opaque_compiler_type_t type,
                                   bool BaseOnly) = 0;

lldb/source/API/SBType.cpp

lldb::TemplateArgumentKind SBType::GetTemplateArgumentKind(uint32_t idx) {
   LLDB_INSTRUMENT_VA(this, idx);
 
   if (IsValid())
     return m_opaque_sp->GetCompilerType(false).GetTemplateArgumentKind(
         idx, /*expand_pack=*/true);
   return eTemplateArgumentKindNull;
 }
 
+bool SBType::IsTypeForcefullyCompleted() {
+  LLDB_INSTRUMENT_VA(this);
+  if (IsValid())
+    return m_opaque_sp->GetCompilerType(false).IsForcefullyCompleted();
+  return false;
+}
+
 SBTypeList::SBTypeList() : m_opaque_up(new TypeListImpl()) {
   LLDB_INSTRUMENT_VA(this);
 }
 
 SBTypeList::SBTypeList(const SBTypeList &rhs)
     : m_opaque_up(new TypeListImpl()) {
   LLDB_INSTRUMENT_VA(this, rhs);
 

lldb/source/Core/ValueObject.cpp

return GetSummaryAsCString(summary_ptr, destination,
                              TypeSummaryOptions().SetLanguage(lang));
 }
 
 bool ValueObject::GetSummaryAsCString(TypeSummaryImpl *summary_ptr,
                                       std::string &destination,
                                       const TypeSummaryOptions &options) {
   destination.clear();
 
+  // If we have a forcefully completed type, don't try and show a summary from
+  // a valid summary string or function because the type is not complete and
+  // no member variables or member functions will be available.
+  if (GetCompilerType().IsForcefullyCompleted()) {
+      destination = "<incomplete type>";
+      return true;
+  }
+
   // ideally we would like to bail out if passing NULL, but if we do so we end
   // up not providing the summary for function pointers anymore
   if (/*summary_ptr == NULL ||*/ m_flags.m_is_getting_summary)
     return false;
 
   m_flags.m_is_getting_summary = true;
 
   TypeSummaryOptions actual_options(options);

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

public:
   // Structure, Unions, Classes
 
   static clang::AccessSpecifier
   ConvertAccessTypeToAccessSpecifier(lldb::AccessType access);
 
   static clang::AccessSpecifier
   UnifyAccessSpecifiers(clang::AccessSpecifier lhs, clang::AccessSpecifier rhs);
 
-  static uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl,
-                                    bool omit_empty_base_classes);
+  uint32_t GetNumBaseClasses(const clang::CXXRecordDecl *cxx_record_decl,
+                             bool omit_empty_base_classes);
+
+  uint32_t GetIndexForRecordChild(const clang::RecordDecl *record_decl,
+                                  clang::NamedDecl *canonical_decl,
+                                  bool omit_empty_base_classes);
+
+  uint32_t GetIndexForRecordBase(const clang::RecordDecl *record_decl,
+                                 const clang::CXXBaseSpecifier *base_spec,
 
   /// Synthesize a clang::Module and return its ID or a default-constructed ID.
   OptionalClangModuleID GetOrCreateClangModule(llvm::StringRef name,
                                                OptionalClangModuleID parent,
                                                bool is_framework = false,
                                                bool is_explicit = false);
 
   CompilerType CreateRecordType(clang::DeclContext *decl_ctx,
public:
   GetAsDeclContext(clang::FunctionDecl *function_decl);
 
   static bool CheckOverloadedOperatorKindParameterCount(
       bool is_method, clang::OverloadedOperatorKind op_kind,
       uint32_t num_params);
 
   bool FieldIsBitfield(clang::FieldDecl *field, uint32_t &bitfield_bit_size);
 
-  static bool RecordHasFields(const clang::RecordDecl *record_decl);
+  bool RecordHasFields(const clang::RecordDecl *record_decl);
+
+  bool BaseSpecifierIsEmpty(const clang::CXXBaseSpecifier *b);
 
   CompilerType CreateObjCClass(llvm::StringRef name,
                                clang::DeclContext *decl_ctx,
                                OptionalClangModuleID owning_module,
                                bool isForwardDecl, bool isInternal,
                                ClangASTMetadata *metadata = nullptr);
 
   // Returns a mask containing bits from the TypeSystemClang::eTypeXXX
#endif
   bool SupportsLanguage(lldb::LanguageType language) override;
 
   static llvm::Optional<std::string> GetCXXClassName(const CompilerType &type);
 
   // Type Completion
 
   bool GetCompleteType(lldb::opaque_compiler_type_t type) override;
 
+  bool IsForcefullyCompleted(lldb::opaque_compiler_type_t type) override;
+
   // Accessors
 
   ConstString GetTypeName(lldb::opaque_compiler_type_t type,
                           bool BaseOnly) override;
 
   ConstString GetDisplayTypeName(lldb::opaque_compiler_type_t type) override;
 
   uint32_t GetTypeInfo(lldb::opaque_compiler_type_t type,

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

for (base_class = cxx_record_decl->bases_begin(),
         base_class_end = cxx_record_decl->bases_end();
          base_class != base_class_end; ++base_class) {
       const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(
           base_class->getType()->getAs<RecordType>()->getDecl());
       if (RecordHasFields(base_class_decl))
         return true;
     }
   }
+
+  // We always want forcefully completed types to show up so we can print a
+  // message in the summary that indicates that the type is incomplete.
+  // This will help users know when they are running into issues with
+  // -flimit-debug-info instead of just seeing nothing if this is a base class
+  // (since we were hiding empty base classes), or nothing when you turn open
+  // an valiable whose type was incomplete.
+  ClangASTMetadata *meta_data = GetMetadata(record_decl);
+  if (meta_data && meta_data->IsForcefullyCompleted())
+    return true;
+
   return false;
 }
 
 #pragma mark Objective-C Classes
 
 CompilerType TypeSystemClang::CreateObjCClass(
     llvm::StringRef name, clang::DeclContext *decl_ctx,
     OptionalClangModuleID owning_module, bool isForwardDecl, bool isInternal,
CompilerType TypeSystemClang::CreateObjCClass(
   SetOwningModule(decl, owning_module);
 
   if (metadata)
     SetMetadata(decl, *metadata);
 
   return GetType(ast.getObjCInterfaceType(decl));
 }
 
-static inline bool BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
+bool TypeSystemClang::BaseSpecifierIsEmpty(const CXXBaseSpecifier *b) {
   return !TypeSystemClang::RecordHasFields(b->getType()->getAsCXXRecordDecl());
 }
 
 uint32_t
 TypeSystemClang::GetNumBaseClasses(const CXXRecordDecl *cxx_record_decl,
                                    bool omit_empty_base_classes) {
   uint32_t num_bases = 0;
   if (cxx_record_decl) {
case clang::Type::RValueReference:
     break;
 
   default:
     break;
   }
   return CompilerType();
 }
 
-static uint32_t GetIndexForRecordBase(const clang::RecordDecl *record_decl,
-                                      const clang::CXXBaseSpecifier *base_spec,
-                                      bool omit_empty_base_classes) {
+uint32_t TypeSystemClang::GetIndexForRecordBase(
+    const clang::RecordDecl *record_decl,
   uint32_t child_idx = 0;
 
   const clang::CXXRecordDecl *cxx_record_decl =
       llvm::dyn_cast<clang::CXXRecordDecl>(record_decl);
 
   if (cxx_record_decl) {
     clang::CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
     for (base_class = cxx_record_decl->bases_begin(),
         base_class_end = cxx_record_decl->bases_end();
          base_class != base_class_end; ++base_class) {
       if (omit_empty_base_classes) {
         if (BaseSpecifierIsEmpty(base_class))
           continue;
       }
 
       if (base_class == base_spec)
         return child_idx;
       ++child_idx;
     }
   }
 
   return UINT32_MAX;
 }
 
-static uint32_t GetIndexForRecordChild(const clang::RecordDecl *record_decl,
-                                       clang::NamedDecl *canonical_decl,
-                                       bool omit_empty_base_classes) {
+uint32_t TypeSystemClang::GetIndexForRecordChild(
+    const clang::RecordDecl *record_decl, clang::NamedDecl *canonical_decl,
   uint32_t child_idx = TypeSystemClang::GetNumBaseClasses(
       llvm::dyn_cast<clang::CXXRecordDecl>(record_decl),
       omit_empty_base_classes);
 
   clang::RecordDecl::field_iterator field, field_end;
   for (field = record_decl->field_begin(), field_end = record_decl->field_end();
        field != field_end; ++field, ++child_idx) {
     if (field->getCanonicalDecl() == canonical_decl)
TypeSystemClang &ScratchTypeSystemClang::GetIsolatedAST(
 
   // Couldn't find the requested sub-AST, so create it now.
   std::unique_ptr<TypeSystemClang> new_ast;
   new_ast.reset(new SpecializedScratchAST(GetSpecializedASTName(feature),
                                           m_triple, CreateASTSource()));
   m_isolated_asts[feature] = std::move(new_ast);
   return *m_isolated_asts[feature];
 }
+
+bool TypeSystemClang::IsForcefullyCompleted(lldb::opaque_compiler_type_t type) {
+  if (type) {
+    clang::QualType qual_type(GetQualType(type));
+    const clang::RecordType *record_type =
+        llvm::dyn_cast<clang::RecordType>(qual_type.getTypePtr());
+    if (record_type) {
+      const clang::RecordDecl *record_decl = record_type->getDecl();
+      assert(record_decl);
+      ClangASTMetadata *metadata = GetMetadata(record_decl);
+      if (metadata)
+        return metadata->IsForcefullyCompleted();
+    }
+  }
+  return false;
+}

lldb/source/Symbol/CompilerType.cpp

 }
 
 bool CompilerType::IsCompleteType() const {
   if (IsValid())
     return m_type_system->IsCompleteType(m_type);
   return false;
 }
 
+bool CompilerType::IsForcefullyCompleted() const {
+  if (IsValid())
+    return m_type_system->IsForcefullyCompleted(m_type);
+  return false;
+}
+
 bool CompilerType::IsConst() const {
   if (IsValid())
     return m_type_system->IsConst(m_type);
   return false;
 }
 
 bool CompilerType::IsCStringType(uint32_t &length) const {
   if (IsValid())

lldb/test/API/functionalities/limit-debug-info/TestLimitDebugInfo.py

 
 class LimitDebugInfoTestCase(TestBase):
 
     def _check_type(self, target, name):
         exe = target.FindModule(lldb.SBFileSpec("a.out"))
         type_ = exe.FindFirstType(name)
         self.trace("type_: %s"%type_)
         self.assertTrue(type_)
+        self.assertTrue(type_.IsTypeComplete())
+        self.assertFalse(type_.IsTypeForcefullyCompleted())
         base = type_.GetDirectBaseClassAtIndex(0).GetType()
         self.trace("base:%s"%base)
         self.assertTrue(base)
         self.assertEquals(base.GetNumberOfFields(), 0)
+        self.assertTrue(base.IsTypeComplete())
+        self.assertTrue(base.IsTypeForcefullyCompleted())
 
     def _check_debug_info_is_limited(self, target):
         # Without other shared libraries we should only see the member declared
         # in the derived class. This serves as a sanity check that we are truly
         # building with limited debug info.
         self._check_type(target, "InheritsFromOne")
         self._check_type(target, "InheritsFromTwo")
 
+    def _check_incomplete_frame_variable_output(self):
+        # Check that the display of the "frame variable" output identifies the
+        # incomplete types. Currently the expression parser will find the real
+        # definition for a type when running an expression for any forcefully
+        # completed types, but "frame variable" won't. I hope to fix this with
+        # a follow up patch, but if we don't find the actual definition we
+        # should clearly show this to the user by showing which types were
+        # incomplete. So this will test verifies the expected output for such
+        # types. We also need to verify the standard "frame variable" output
+        # which will inline all of the members on one line, versus the full
+        # output from "frame variable --raw" and a few other options.
+        # self.expect("frame variable two_as_member", error=True,
+        #     substrs=["no member named 'one' in 'InheritsFromOne'"])
+
+        command_expect_pairs = [
+            # Test standard "frame variable" output for types to make sure
+            # "<incomplete type>" shows up where we expect it to
+            ["var two_as_member", [
+                "(TwoAsMember) ::two_as_member = (two = <incomplete type>, member = 47)"]
+            ],
+            ["var inherits_from_one", [
+                "(InheritsFromOne) ::inherits_from_one = (One = <incomplete type>, member = 47)"]
+            ],
+            ["var inherits_from_two", [
+                "(InheritsFromTwo) ::inherits_from_two = (Two = <incomplete type>, member = 47)"]
+            ],
+            ["var one_as_member", [
+                "(OneAsMember) ::one_as_member = (one = <incomplete type>, member = 47)"]
+            ],
+            ["var two_as_member", [
+                "(TwoAsMember) ::two_as_member = (two = <incomplete type>, member = 47)"]
+            ],
+            ["var array_of_one", [
+                "(array::One[3]) ::array_of_one = ([0] = <incomplete type>, [1] = <incomplete type>, [2] = <incomplete type>)"]
+            ],
+            ["var array_of_two", [
+                "(array::Two[3]) ::array_of_two = ([0] = <incomplete type>, [1] = <incomplete type>, [2] = <incomplete type>)"]
+            ],
+            ["var shadowed_one", [
+                "(ShadowedOne) ::shadowed_one = (func_shadow::One = <incomplete type>, member = 47)"]
+            ],
+
+            # Now test "frame variable --show-types output" which has multi-line
+            # output and should not always show classes that were forcefully
+            # completed to the user to let them know they have a type that should
+            # have been complete but wasn't.
+            ["var --show-types inherits_from_one", [
+                "(InheritsFromOne) ::inherits_from_one = {",
+                "  (One) One = <incomplete type> {}",
+                "  (int) member = 47",
+                "}"]
+            ],
+            ["var --show-types inherits_from_two", [
+                "(InheritsFromTwo) ::inherits_from_two = {",
+                "  (Two) Two = <incomplete type> {}",
+                "  (int) member = 47",
+                "}"]
+            ],
+            ["var  --show-types one_as_member", [
+                "(OneAsMember) ::one_as_member = {",
+                "  (member::One) one = <incomplete type> {}",
+                "  (int) member = 47",
+                "}"]
+            ],
+            ["var  --show-types two_as_member", [
+                "(TwoAsMember) ::two_as_member = {",
+                "  (member::Two) two = <incomplete type> {}",
+                "  (int) member = 47",
+                "}"]
+            ],
+            ["var  --show-types array_of_one", [
+                "(array::One[3]) ::array_of_one = {",
+                "  (array::One) [0] = <incomplete type> {}",
+                "  (array::One) [1] = <incomplete type> {}",
+                "  (array::One) [2] = <incomplete type> {}",
+                "}"]
+            ],
+            ["var  --show-types array_of_two", [
+                "(array::Two[3]) ::array_of_two = {",
+                "  (array::Two) [0] = <incomplete type> {}",
+                "  (array::Two) [1] = <incomplete type> {}",
+                "  (array::Two) [2] = <incomplete type> {}",
+                "}"]
+            ],
+            ["var  --show-types shadowed_one", [
+                "(ShadowedOne) ::shadowed_one = {",
+                "  (func_shadow::One) func_shadow::One = <incomplete type> {}",
+                "  (int) member = 47",
+                "}"]
+            ],
+        ]
+        for command, expect_items in command_expect_pairs:
+            self.expect(command, substrs=expect_items)
+
     @skipIf(bugnumber="pr46284", debug_info="gmodules")
     @skipIfWindows # Clang emits type info even with -flimit-debug-info
     # Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call
     # by-value functions.
     @skipIf(compiler="clang", compiler_version=['<', '7.0'])
     def test_one_and_two_debug(self):
         self.build()
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
 
         self._check_debug_info_is_limited(target)
 
         lldbutil.run_to_name_breakpoint(self, "main",
                                         extra_images=["one", "two"])
 
         # But when other shared libraries are loaded, we should be able to see
         # all members.
         self.expect_expr("inherits_from_one.member", result_value="47")
         self.expect_expr("inherits_from_one.one", result_value="142")
         self.expect_expr("inherits_from_two.member", result_value="47")
         self.expect_expr("inherits_from_two.one", result_value="142")
         self.expect_expr("inherits_from_two.two", result_value="242")
def test_one_and_two_debug(self):
 
         self.expect_expr("get_one().member", result_value="124")
         self.expect_expr("get_two().one().member", result_value="124")
         self.expect_expr("get_two().member", result_value="224")
 
         self.expect_expr("shadowed_one.member", result_value="47")
         self.expect_expr("shadowed_one.one", result_value="142")
 
+        self._check_incomplete_frame_variable_output()
+
     @skipIf(bugnumber="pr46284", debug_info="gmodules")
     @skipIfWindows # Clang emits type info even with -flimit-debug-info
     # Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call
     # by-value functions.
     @skipIf(compiler="clang", compiler_version=['<', '7.0'])
     def test_two_debug(self):
         self.build(dictionary=dict(STRIP_ONE="1"))
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
def test_two_debug(self):
         self.expect_expr("array_of_two[2].member", result_value="274")
 
         self.expect("expr get_one().member", error=True,
                 substrs=["calling 'get_one' with incomplete return type 'result::One'"])
         self.expect("expr get_two().one().member", error=True,
                 substrs=["calling 'one' with incomplete return type 'result::One'"])
         self.expect_expr("get_two().member", result_value="224")
 
+        self._check_incomplete_frame_variable_output()
+
     @skipIf(bugnumber="pr46284", debug_info="gmodules")
     @skipIfWindows # Clang emits type info even with -flimit-debug-info
     # Requires DW_CC_pass_by_* attributes from Clang 7 to correctly call
     # by-value functions.
     @skipIf(compiler="clang", compiler_version=['<', '7.0'])
     def test_one_debug(self):
         self.build(dictionary=dict(STRIP_TWO="1"))
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
def test_one_debug(self):
         self.expect("expr array_of_two[2].member", error=True,
                 substrs=["no member named 'member' in 'array::Two'"])
 
         self.expect_expr("get_one().member", result_value="124")
         self.expect("expr get_two().one().member", error=True,
                 substrs=["calling 'get_two' with incomplete return type 'result::Two'"])
         self.expect("expr get_two().member", error=True,
                 substrs=["calling 'get_two' with incomplete return type 'result::Two'"])
+
+        self._check_incomplete_frame_variable_output()

lldb/unittests/Symbol/TestTypeSystemClang.cpp

TEST_F(TestTypeSystemClang, TestRecordHasFields) {
   CompilerType empty_base = m_ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "EmptyBase",
       clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr);
   TypeSystemClang::StartTagDeclarationDefinition(empty_base);
   TypeSystemClang::CompleteTagDeclarationDefinition(empty_base);
 
   RecordDecl *empty_base_decl = TypeSystemClang::GetAsRecordDecl(empty_base);
   EXPECT_NE(nullptr, empty_base_decl);
-  EXPECT_FALSE(TypeSystemClang::RecordHasFields(empty_base_decl));
+  EXPECT_FALSE(m_ast->RecordHasFields(empty_base_decl));
 
   // Test that a record with direct fields returns true
   CompilerType non_empty_base = m_ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "NonEmptyBase",
       clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr);
   TypeSystemClang::StartTagDeclarationDefinition(non_empty_base);
   FieldDecl *non_empty_base_field_decl = m_ast->AddFieldToRecordType(
       non_empty_base, "MyField", int_type, eAccessPublic, 0);
   TypeSystemClang::CompleteTagDeclarationDefinition(non_empty_base);
   RecordDecl *non_empty_base_decl =
       TypeSystemClang::GetAsRecordDecl(non_empty_base);
   EXPECT_NE(nullptr, non_empty_base_decl);
   EXPECT_NE(nullptr, non_empty_base_field_decl);
-  EXPECT_TRUE(TypeSystemClang::RecordHasFields(non_empty_base_decl));
+  EXPECT_TRUE(m_ast->RecordHasFields(non_empty_base_decl));
 
   std::vector<std::unique_ptr<clang::CXXBaseSpecifier>> bases;
 
   // Test that a record with no direct fields, but fields in a base returns true
   CompilerType empty_derived = m_ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "EmptyDerived",
       clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr);
   TypeSystemClang::StartTagDeclarationDefinition(empty_derived);
   std::unique_ptr<clang::CXXBaseSpecifier> non_empty_base_spec =
       m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(),
                                       lldb::eAccessPublic, false, false);
   bases.push_back(std::move(non_empty_base_spec));
   bool result = m_ast->TransferBaseClasses(empty_derived.GetOpaqueQualType(),
                                            std::move(bases));
   TypeSystemClang::CompleteTagDeclarationDefinition(empty_derived);
   EXPECT_TRUE(result);
   CXXRecordDecl *empty_derived_non_empty_base_cxx_decl =
       m_ast->GetAsCXXRecordDecl(empty_derived.GetOpaqueQualType());
   RecordDecl *empty_derived_non_empty_base_decl =
       TypeSystemClang::GetAsRecordDecl(empty_derived);
-  EXPECT_EQ(1u, TypeSystemClang::GetNumBaseClasses(
+  EXPECT_EQ(1u, m_ast->GetNumBaseClasses(
                     empty_derived_non_empty_base_cxx_decl, false));
-  EXPECT_TRUE(
-      TypeSystemClang::RecordHasFields(empty_derived_non_empty_base_decl));
+  EXPECT_TRUE(m_ast->RecordHasFields(empty_derived_non_empty_base_decl));
 
   // Test that a record with no direct fields, but fields in a virtual base
   // returns true
   CompilerType empty_derived2 = m_ast->CreateRecordType(
       nullptr, OptionalClangModuleID(), lldb::eAccessPublic, "EmptyDerived2",
       clang::TTK_Struct, lldb::eLanguageTypeC_plus_plus, nullptr);
   TypeSystemClang::StartTagDeclarationDefinition(empty_derived2);
   std::unique_ptr<CXXBaseSpecifier> non_empty_vbase_spec =
       m_ast->CreateBaseClassSpecifier(non_empty_base.GetOpaqueQualType(),
                                       lldb::eAccessPublic, true, false);
   bases.push_back(std::move(non_empty_vbase_spec));
   result = m_ast->TransferBaseClasses(empty_derived2.GetOpaqueQualType(),
                                       std::move(bases));
   TypeSystemClang::CompleteTagDeclarationDefinition(empty_derived2);
   EXPECT_TRUE(result);
   CXXRecordDecl *empty_derived_non_empty_vbase_cxx_decl =
       m_ast->GetAsCXXRecordDecl(empty_derived2.GetOpaqueQualType());
   RecordDecl *empty_derived_non_empty_vbase_decl =
       TypeSystemClang::GetAsRecordDecl(empty_derived2);
-  EXPECT_EQ(1u, TypeSystemClang::GetNumBaseClasses(
+  EXPECT_EQ(1u, m_ast->GetNumBaseClasses(
                     empty_derived_non_empty_vbase_cxx_decl, false));
   EXPECT_TRUE(
-      TypeSystemClang::RecordHasFields(empty_derived_non_empty_vbase_decl));
+      m_ast->RecordHasFields(empty_derived_non_empty_vbase_decl));
 }
 
 TEST_F(TestTypeSystemClang, TemplateArguments) {
   TypeSystemClang::TemplateParameterInfos infos;
   infos.names.push_back("T");
   infos.args.push_back(TemplateArgument(m_ast->getASTContext().IntTy));
   infos.names.push_back("I");
   llvm::APSInt arg(llvm::APInt(8, 47));
TEST_F(TestTypeSystemClang, GetExeModuleWhenMissingSymbolFile) {
   lldb_private::Type t(0, nullptr, ConstString("MyType"), llvm::None, nullptr,
                        0, {}, {}, compiler_type,
                        lldb_private::Type::ResolveState::Full);
   // Test that getting the execution module when no type system is present
   // is handled gracefully.
   ModuleSP module = t.GetExeModule();
   EXPECT_EQ(module.get(), nullptr);
 }
-