[lldb] Don't recursively load types of static member variables in the DWARF AST parser

[teemperor]

Summary

When LLDB's DWARF parser is parsing the member DIEs of a struct/class it
currently fully resolves the types of static member variables in a class before
adding the respective VarDecl to the record.

For record types fully resolving the type will also parse the member DIEs of the
respective class. The other way of resolving is just 'forward' resolving the type
which will try to load only the minimum amount of information about the type
(for records that would only be the name/kind of the type). Usually we always
resolve types on-demand so it's rarely useful to speculatively fully resolve
them on the first use.

This patch changes makes that we only 'forward' resolve the types of static
members. This solves the fact that LLDB unnecessarily loads debug information
to parse the type if it's maybe not needed later and it also avoids a crash where
the parsed type might in turn reference the surrounding class that is currently
being parsed.

The new test case demonstrates the crash that might happen. The crash happens
with the following steps:

1. We parse class ToLayout and it's members.
2. We parse the static class member and fully resolve its type (DependsOnParam2<ToLayout>).
3. That type has a non-static class member DependsOnParam1<ToLayout> for which LLDB will try to calculate the size.
4. The layout (and size)DependsOnParam1<ToLayout> turns depends on the ToLayout size/layout.
5. Clang will calculate the record layout/size for ToLayout even though we are currently parsing it and it's missing it's non-static member.

The created is missing the offset for the yet unparsed non-static member. If we later try to
get the offset we end up hitting different asserts. Most common is the one in TypeSystemClang::DumpValue
where it checks that the record layout has offsets for the current FieldDecl.

assert(field_idx < record_layout.getFieldCount());

Fixed rdar://67910011

[teemperor]

• Add missing test case.

[shafik]

LGTM

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

void DWARFASTParserClang::ParseSingleMember(
   // Handle static members
   if (is_external && member_byte_offset == UINT32_MAX) {
     Type *var_type = die.ResolveTypeUID(encoding_form.Reference());
 
     if (var_type) {
       if (accessibility == eAccessNone)
         accessibility = eAccessPublic;
       TypeSystemClang::AddVariableToRecordType(
-          class_clang_type, name, var_type->GetLayoutCompilerType(),
+          class_clang_type, name, var_type->GetForwardCompilerType(),
           accessibility);
     }
     return;
   }
 
   if (!is_artificial) {
     Type *member_type = die.ResolveTypeUID(encoding_form.Reference());
 

lldb/test/API/functionalities/lazy-loading/TestLazyLoading.py

class TestCase(TestBase):
     struct_behind_ptr_decl = [struct_decl_kind, "StructBehindPointer"]
     struct_behind_ref_decl = [struct_decl_kind, "StructBehindRef"]
     struct_member_decl = [struct_decl_kind, "StructMember"]
     some_struct_decl = [struct_decl_kind, "SomeStruct"]
     other_struct_decl = [struct_decl_kind, "OtherStruct"]
     class_in_namespace_decl = [class_decl_kind, "ClassInNamespace"]
     class_we_enter_decl = [class_decl_kind, "ClassWeEnter"]
     class_member_decl = [struct_decl_kind, "ClassMember"]
+    class_static_member_decl = [struct_decl_kind, "StaticClassMember"]
     unused_class_member_decl = [struct_decl_kind, "UnusedClassMember"]
     unused_class_member_ptr_decl = [struct_decl_kind, "UnusedClassMemberPtr"]
 
     def assert_no_decls_loaded(self):
         """
         Asserts that no known declarations in this test are loaded
         into the module's AST.
         """
         self.assert_decl_not_loaded(self.struct_first_member_decl)
         self.assert_decl_not_loaded(self.struct_behind_ptr_decl)
         self.assert_decl_not_loaded(self.struct_behind_ref_decl)
         self.assert_decl_not_loaded(self.struct_member_decl)
         self.assert_decl_not_loaded(self.some_struct_decl)
         self.assert_decl_not_loaded(self.other_struct_decl)
         self.assert_decl_not_loaded(self.class_in_namespace_decl)
         self.assert_decl_not_loaded(self.class_member_decl)
+        self.assert_decl_not_loaded(self.class_static_member_decl)
         self.assert_decl_not_loaded(self.unused_class_member_decl)
 
     def get_ast_dump(self):
         """Returns the dumped Clang AST of the module as a string"""
         res = lldb.SBCommandReturnObject()
         ci = self.dbg.GetCommandInterpreter()
         ci.HandleCommand('target modules dump ast a.out', res)
         self.assertTrue(res.Succeeded())
def test_class_function_access_member(self):
 
         # We loaded the current class we touched.
         self.assert_decl_loaded(self.class_we_enter_decl)
         # We loaded the unused members of this class.
         self.assert_decl_loaded(self.unused_class_member_decl)
         self.assert_decl_not_completed(self.unused_class_member_ptr_decl)
         # We loaded the member we used.
         self.assert_decl_loaded(self.class_member_decl)
+        # We didn't load the type of the unused static member.
+        self.assert_decl_not_completed(self.class_static_member_decl)
 
         # This should not have loaded anything else.
         self.assert_decl_not_loaded(self.other_struct_decl)
         self.assert_decl_not_loaded(self.some_struct_decl)
         self.assert_decl_not_loaded(self.class_in_namespace_decl)
 

lldb/test/API/functionalities/lazy-loading/main.cpp

 struct OtherStruct {
   int member_int;
 };
 
 //----------------------------------------------------------------------------//
 // Class loading declarations.
 
 struct ClassMember { int i; };
+struct StaticClassMember { int i; };
 struct UnusedClassMember { int i; };
 struct UnusedClassMemberPtr { int i; };
 
 namespace NS {
 class ClassInNamespace {
   int i;
 };
 class ClassWeEnter {
 public:
   int dummy; // Prevent bug where LLDB always completes first member.
   ClassMember member;
+  static StaticClassMember static_member;
   UnusedClassMember unused_member;
   UnusedClassMemberPtr *unused_member_ptr;
   int enteredFunction() {
     return member.i; // Location: class function
   }
 };
+StaticClassMember ClassWeEnter::static_member;
 };
 
 //----------------------------------------------------------------------------//
 // Function we can stop in.
 
 int functionWithOtherStruct() {
   OtherStruct other_struct_var;
   other_struct_var.member_int++; // Location: other struct function