| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| |
| """ |
| This test ensures that we only create Clang AST nodes in our module AST |
| when we actually need them. |
| |
| All tests in this file behave like this: |
| 1. Use LLDB to do something (expression evaluation, breakpoint setting, etc.). |
| 2. Check that certain Clang AST nodes were not loaded during the previous |
| step. |
| """ |
| |
| class TestCase(TestBase): |
| |
| NO_DEBUG_INFO_TESTCASE = True |
| mydir = TestBase.compute_mydir(__file__) |
| |
| def setUp(self): |
| TestBase.setUp(self) |
| # Only build this test once. |
| self.build() |
| |
| # Clang declaration kind we are looking for. |
| class_decl_kind = "CXXRecordDecl" |
| # FIXME: This shouldn't be a CXXRecordDecl, but that's how we model |
| # structs in Clang. |
| struct_decl_kind = "CXXRecordDecl" |
| |
| # The decls we use in this program in the format that |
| # decl_in_line and decl_completed_in_line expect (which is a pair of |
| # node type and the unqualified declaration name. |
| struct_first_member_decl = [struct_decl_kind, "StructFirstMember"] |
| 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()) |
| return res.GetOutput() |
| |
| def decl_in_line(self, line, decl): |
| """ |
| Returns true iff the given line declares the given Clang decl. |
| The line is expected to be in the form of Clang's AST dump. |
| """ |
| line = line.rstrip() + "\n" |
| decl_kind = "-" + decl[0] + " " |
| # Either the decl is somewhere in the line or at the end of |
| # the line. |
| decl_name = " " + decl[1] + " " |
| decl_name_eol = " " + decl[1] + "\n" |
| if not decl_kind in line: |
| return False |
| return decl_name in line or decl_name_eol in line |
| |
| def decl_completed_in_line(self, line, decl): |
| """ |
| Returns true iff the given line declares the given Clang decl and |
| the decl was completed (i.e., it has no undeserialized declarations |
| in it). |
| """ |
| return self.decl_in_line(line, decl) and not "<undeserialized declarations>" in line |
| |
| # The following asserts are used for checking if certain Clang declarations |
| # were loaded or not since the target was created. |
| |
| def assert_decl_loaded(self, decl): |
| """ |
| Asserts the given decl is currently loaded. |
| Note: This test is about checking that types/declarations are not |
| loaded. If this assert fails it is usually fine to turn it into a |
| assert_decl_not_loaded or assert_decl_not_completed assuming LLDB's |
| functionality has not suffered by not loading this declaration. |
| """ |
| ast = self.get_ast_dump() |
| found = False |
| for line in ast.splitlines(): |
| if self.decl_in_line(line, decl): |
| found = True |
| self.assertTrue(self.decl_completed_in_line(line, decl), |
| "Should have called assert_decl_not_completed") |
| self.assertTrue(found, "Declaration no longer loaded " + str(decl) + |
| ".\nAST:\n" + ast) |
| |
| def assert_decl_not_completed(self, decl): |
| """ |
| Asserts that the given decl is currently not completed in the module's |
| AST. It may be loaded but then can can only contain undeserialized |
| declarations. |
| """ |
| ast = self.get_ast_dump() |
| found = False |
| for line in ast.splitlines(): |
| error_msg = "Unexpected completed decl: '" + line + "'.\nAST:\n" + ast |
| self.assertFalse(self.decl_completed_in_line(line, decl), error_msg) |
| |
| def assert_decl_not_loaded(self, decl): |
| """ |
| Asserts that the given decl is currently not loaded in the module's |
| AST. |
| """ |
| ast = self.get_ast_dump() |
| found = False |
| for line in ast.splitlines(): |
| error_msg = "Unexpected loaded decl: '" + line + "'\nAST:\n" + ast |
| self.assertFalse(self.decl_in_line(line, decl), error_msg) |
| |
| |
| def clean_setup(self, location): |
| """ |
| Runs to the line with the source line with the given location string |
| and ensures that our module AST is empty. |
| """ |
| lldbutil.run_to_source_breakpoint(self, |
| "// Location: " + location, lldb.SBFileSpec("main.cpp")) |
| # Make sure no declarations are loaded initially. |
| self.assert_no_decls_loaded() |
| |
| @add_test_categories(["dwarf"]) |
| def test_arithmetic_expression_in_main(self): |
| """ Runs a simple arithmetic expression which should load nothing. """ |
| self.clean_setup(location="multiple locals function") |
| |
| self.expect("expr 1 + (int)2.0", substrs=['(int) $0']) |
| |
| # This should not have loaded any decls. |
| self.assert_no_decls_loaded() |
| |
| @add_test_categories(["dwarf"]) |
| def test_printing_local_variable_in_other_struct_func(self): |
| """ |
| Prints a local variable and makes sure no unrelated types are loaded. |
| """ |
| self.clean_setup(location="other struct function") |
| |
| self.expect("expr other_struct_var", substrs=['(OtherStruct) $0']) |
| # The decl we run on was loaded. |
| self.assert_decl_loaded(self.other_struct_decl) |
| |
| # This should not have loaded anything else. |
| self.assert_decl_not_loaded(self.some_struct_decl) |
| self.assert_decl_not_loaded(self.class_in_namespace_decl) |
| |
| @add_test_categories(["dwarf"]) |
| def test_printing_struct_with_multiple_locals(self): |
| """ |
| Prints a local variable and checks that we don't load other local |
| variables. |
| """ |
| self.clean_setup(location="multiple locals function") |
| |
| self.expect("expr struct_var", substrs=['(SomeStruct) $0']) |
| |
| # We loaded SomeStruct and its member types for printing. |
| self.assert_decl_loaded(self.some_struct_decl) |
| self.assert_decl_loaded(self.struct_behind_ptr_decl) |
| self.assert_decl_loaded(self.struct_behind_ref_decl) |
| |
| # FIXME: We don't use these variables, but we seem to load all local |
| # local variables. |
| self.assert_decl_not_completed(self.other_struct_decl) |
| self.assert_decl_not_completed(self.class_in_namespace_decl) |
| |
| @add_test_categories(["dwarf"]) |
| def test_addr_of_struct(self): |
| """ |
| Prints the address of a local variable (which is a struct). |
| """ |
| self.clean_setup(location="multiple locals function") |
| |
| self.expect("expr &struct_var", substrs=['(SomeStruct *) $0']) |
| |
| # We loaded SomeStruct. |
| self.assert_decl_loaded(self.some_struct_decl) |
| |
| # The member declarations should not be completed. |
| self.assert_decl_not_completed(self.struct_behind_ptr_decl) |
| self.assert_decl_not_completed(self.struct_behind_ref_decl) |
| |
| # FIXME: The first member was behind a pointer so it shouldn't be |
| # completed. Somehow LLDB really wants to load the first member, so |
| # that is why have it defined here. |
| self.assert_decl_loaded(self.struct_first_member_decl) |
| |
| # FIXME: We don't use these variables, but we seem to load all local |
| # local variables. |
| self.assert_decl_not_completed(self.other_struct_decl) |
| self.assert_decl_not_completed(self.class_in_namespace_decl) |
| |
| @add_test_categories(["dwarf"]) |
| def test_class_function_access_member(self): |
| self.clean_setup(location="class function") |
| |
| self.expect("expr member", substrs=['(ClassMember) $0']) |
| |
| # 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) |
| |
