| """ |
| Test completing types using information from other shared libraries. |
| """ |
| |
| import os |
| import lldb |
| from lldbsuite.test.decorators import * |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import lldbutil |
| |
| |
| 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()) |
| base = type_.GetDirectBaseClassAtIndex(0).GetType() |
| self.trace("base:%s" % base) |
| self.assertTrue(base) |
| self.assertEquals(base.GetNumberOfFields(), 0) |
| self.assertFalse(base.IsTypeComplete()) |
| |
| 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") |
| |
| # Check that the statistics show that we had incomplete debug info. |
| stats = self.get_stats() |
| # Find the a.out module info in the stats and verify it has the |
| # "debugInfoHadIncompleteTypes" key value pair set to True |
| exe_module_found = False |
| for module in stats["modules"]: |
| if module["path"].endswith("a.out"): |
| self.assertTrue(module["debugInfoHadIncompleteTypes"]) |
| exe_module_found = True |
| break |
| self.assertTrue(exe_module_found) |
| # Verify that "totalModuleCountWithIncompleteTypes" at the top level |
| # is greater than zero which shows we had incomplete debug info in a |
| # module |
| self.assertGreater(stats["totalModuleCountWithIncompleteTypes"], 0) |
| |
| 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") |
| |
| self.expect_expr("one_as_member.member", result_value="47") |
| self.expect_expr("one_as_member.one.member", result_value="147") |
| self.expect_expr("two_as_member.member", result_value="47") |
| self.expect_expr("two_as_member.two.one.member", result_value="147") |
| self.expect_expr("two_as_member.two.member", result_value="247") |
| |
| self.expect_expr("array_of_one[2].member", result_value="174") |
| self.expect_expr("array_of_two[2].one[2].member", result_value="174") |
| self.expect_expr("array_of_two[2].member", result_value="274") |
| |
| 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")) |
| |
| self._check_debug_info_is_limited(target) |
| |
| lldbutil.run_to_name_breakpoint(self, "main", extra_images=["one", "two"]) |
| |
| # This time, we should only see the members from the second library. |
| self.expect_expr("inherits_from_one.member", result_value="47") |
| self.expect( |
| "expr inherits_from_one.one", |
| error=True, |
| substrs=["no member named 'one' in 'InheritsFromOne'"], |
| ) |
| self.expect_expr("inherits_from_two.member", result_value="47") |
| self.expect( |
| "expr inherits_from_two.one", |
| error=True, |
| substrs=["no member named 'one' in 'InheritsFromTwo'"], |
| ) |
| self.expect_expr("inherits_from_two.two", result_value="242") |
| |
| self.expect_expr("one_as_member.member", result_value="47") |
| self.expect( |
| "expr one_as_member.one.member", |
| error=True, |
| substrs=["no member named 'member' in 'member::One'"], |
| ) |
| self.expect_expr("two_as_member.member", result_value="47") |
| self.expect( |
| "expr two_as_member.two.one.member", |
| error=True, |
| substrs=["no member named 'member' in 'member::One'"], |
| ) |
| self.expect_expr("two_as_member.two.member", result_value="247") |
| |
| self.expect( |
| "expr array_of_one[2].member", |
| error=True, |
| substrs=["no member named 'member' in 'array::One'"], |
| ) |
| self.expect( |
| "expr array_of_two[2].one[2].member", |
| error=True, |
| substrs=["no member named 'member' in 'array::One'"], |
| ) |
| 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")) |
| |
| self._check_debug_info_is_limited(target) |
| |
| lldbutil.run_to_name_breakpoint(self, "main", extra_images=["one", "two"]) |
| |
| # In this case we should only see the members from the second library. |
| # Note that we cannot see inherits_from_two.one because without debug |
| # info for "Two", we cannot determine that it in fact inherits from |
| # "One". |
| 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", |
| error=True, |
| substrs=["no member named 'one' in 'InheritsFromTwo'"], |
| ) |
| self.expect( |
| "expr inherits_from_two.two", |
| error=True, |
| substrs=["no member named 'two' in 'InheritsFromTwo'"], |
| ) |
| |
| self.expect_expr("one_as_member.member", result_value="47") |
| self.expect_expr("one_as_member.one.member", result_value="147") |
| self.expect_expr("two_as_member.member", result_value="47") |
| self.expect( |
| "expr two_as_member.two.one.member", |
| error=True, |
| substrs=["no member named 'one' in 'member::Two'"], |
| ) |
| self.expect( |
| "expr two_as_member.two.member", |
| error=True, |
| substrs=["no member named 'member' in 'member::Two'"], |
| ) |
| |
| self.expect_expr("array_of_one[2].member", result_value="174") |
| self.expect( |
| "expr array_of_two[2].one[2].member", |
| error=True, |
| substrs=["no member named 'one' in 'array::Two'"], |
| ) |
| 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() |
