diff options
Diffstat (limited to 'gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp')
228 files changed, 8241 insertions, 0 deletions
diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/Makefile new file mode 100644 index 00000000000..4c053a09c75 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/Makefile @@ -0,0 +1,7 @@ +# There is no guaranteed order in which the linker will order these +# files, so we just have a lot of them to make it unlikely that we hit +# the right one first by pure luck. + +CXX_SOURCES := main.cpp a.cpp b.cpp c.cpp d.cpp e.cpp f.cpp g.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/TestCPPAccelerator.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/TestCPPAccelerator.py new file mode 100644 index 00000000000..3705e95c600 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/TestCPPAccelerator.py @@ -0,0 +1,31 @@ +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CPPAcceleratorTableTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipUnlessDarwin + @skipIf(debug_info=no_match(["dwarf"])) + def test(self): + """Test that type lookups fail early (performance)""" + self.build() + logfile = self.getBuildArtifact('dwarf.log') + self.expect('log enable dwarf lookups -f' + logfile) + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, 'break here', lldb.SBFileSpec('main.cpp')) + # Pick one from the middle of the list to have a high chance + # of it not being in the first file looked at. + self.expect('frame variable inner_d') + + log = open(logfile, 'r') + n = 0 + for line in log: + if re.findall(r'[abcdefg]\.o: FindByNameAndTag\(\)', line): + self.assertTrue("d.o" in line) + n += 1 + + self.assertEqual(n, 1, log) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/a.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/a.cpp new file mode 100644 index 00000000000..d9f758e1991 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/a.cpp @@ -0,0 +1,2 @@ +#include "source.h" +CLASS(A) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/b.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/b.cpp new file mode 100644 index 00000000000..a0cdffa14f1 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/b.cpp @@ -0,0 +1,2 @@ +#include "source.h" +CLASS(B) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/c.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/c.cpp new file mode 100644 index 00000000000..1bd7172b771 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/c.cpp @@ -0,0 +1,2 @@ +#include "source.h" +CLASS(C) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/d.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/d.cpp new file mode 100644 index 00000000000..e43c2ad05aa --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/d.cpp @@ -0,0 +1,2 @@ +#include "source.h" +CLASS(D) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/e.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/e.cpp new file mode 100644 index 00000000000..a3008f71f65 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/e.cpp @@ -0,0 +1,2 @@ +#include "source.h" +CLASS(E) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/f.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/f.cpp new file mode 100644 index 00000000000..77df296183e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/f.cpp @@ -0,0 +1,2 @@ +#include "source.h" +CLASS(F) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/g.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/g.cpp new file mode 100644 index 00000000000..e1446918891 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/g.cpp @@ -0,0 +1,2 @@ +#include "source.h" +CLASS(G) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/main.cpp new file mode 100644 index 00000000000..b7eb252bad8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/main.cpp @@ -0,0 +1,28 @@ +#define CLASS(NAME) \ + class NAME { \ + public: \ + struct Inner; \ + Inner *i = nullptr; \ + }; \ +NAME::Inner &getInner##NAME(); + +CLASS(A) +CLASS(B) +CLASS(C) +CLASS(D) +CLASS(E) +CLASS(F) +CLASS(G) + +int main() +{ + A::Inner &inner_a = getInnerA(); + B::Inner &inner_b = getInnerB(); + C::Inner &inner_c = getInnerC(); + D::Inner &inner_d = getInnerD(); + E::Inner &inner_e = getInnerE(); + F::Inner &inner_f = getInnerF(); + G::Inner &inner_g = getInnerG(); + + return 0; // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/source.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/source.h new file mode 100644 index 00000000000..214e7dada2e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/accelerator-table/source.h @@ -0,0 +1,12 @@ +#define CLASS(NAME) \ + class NAME { \ + public: \ + class Inner { \ + int j = #NAME[0]; \ + }; \ + Inner *i = nullptr; \ + }; \ + \ + static NAME::Inner inner; \ + static NAME obj; \ + NAME::Inner &getInner##NAME() { return inner; } diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py new file mode 100644 index 00000000000..fe3a8324348 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py @@ -0,0 +1,41 @@ +""" +Tests that auto types work +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CPPAutoTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureAll( + compiler="gcc", + bugnumber="GCC generates incomplete debug info") + @expectedFailureAll(oslist=['windows'], bugnumber="llvm.org/pr26339") + @expectedFailureNetBSD + def test_with_run_command(self): + """Test that auto types work in the expression parser""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + line = line_number('main.cpp', '// break here') + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) + + self.runCmd("process launch", RUN_SUCCEEDED) + + self.expect('expr auto f = 123456; f', substrs=['int', '123456']) + self.expect( + 'expr struct Test { int x; int y; Test() : x(123), y(456) {} }; auto t = Test(); t', + substrs=[ + 'Test', + '123', + '456']) + self.expect( + 'expr auto s = helloworld; s', + substrs=[ + 'string', + 'hello world']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/main.cpp new file mode 100644 index 00000000000..d411af67911 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/auto/main.cpp @@ -0,0 +1,20 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <string> + +int main() +{ + std::string helloworld("hello world"); + + // Ensure std::string copy constructor is present in the binary, as we will + // use it in an expression. + std::string other = helloworld; + + return 0; // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/TestCppBitfields.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/TestCppBitfields.py new file mode 100644 index 00000000000..1b362e6b04f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/TestCppBitfields.py @@ -0,0 +1,105 @@ +"""Show bitfields and check that they display correctly.""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CppBitfieldsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.line = line_number('main.cpp', '// Set break point at this line.') + + # BitFields exhibit crashes in record layout on Windows + # (http://llvm.org/pr21800) + @skipIfWindows + def test_and_run_command(self): + """Test 'frame variable ...' on a variable with bitfields.""" + self.build() + + lldbutil.run_to_source_breakpoint(self, '// Set break point at this line.', + lldb.SBFileSpec("main.cpp", False)) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) + + self.expect("expr (lba.a)", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['unsigned int', '2']) + self.expect("expr (lbb.b)", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['unsigned int', '3']) + self.expect("expr (lbc.c)", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['unsigned int', '4']) + self.expect("expr (lbd.a)", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['unsigned int', '5']) + self.expect("expr (clang_example.f.a)", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['uint64_t', '1']) + + self.expect( + "frame variable --show-types lba", + VARIABLES_DISPLAYED_CORRECTLY, + substrs=[ + '(int:32) = ', + '(unsigned int:20) a = 2', + ]) + + self.expect( + "frame variable --show-types lbb", + VARIABLES_DISPLAYED_CORRECTLY, + substrs=[ + '(unsigned int:1) a = 1', + '(int:31) =', + '(unsigned int:20) b = 3', + ]) + + self.expect( + "frame variable --show-types lbc", + VARIABLES_DISPLAYED_CORRECTLY, + substrs=[ + '(int:22) =', + '(unsigned int:1) a = 1', + '(unsigned int:1) b = 0', + '(unsigned int:5) c = 4', + '(unsigned int:1) d = 1', + '(int:2) =', + '(unsigned int:20) e = 20', + ]) + + self.expect( + "frame variable --show-types lbd", + VARIABLES_DISPLAYED_CORRECTLY, + substrs=[ + '(char [3]) arr = "ab"', + '(int:32) =', + '(unsigned int:20) a = 5', + ]) + + self.expect( + "frame variable --show-types clang_example", + VARIABLES_DISPLAYED_CORRECTLY, + substrs=[ + '(int:22) =', + '(uint64_t:1) a = 1', + '(uint64_t:1) b = 0', + '(uint64_t:1) c = 1', + '(uint64_t:1) d = 0', + '(uint64_t:1) e = 1', + '(uint64_t:1) f = 0', + '(uint64_t:1) g = 1', + '(uint64_t:1) h = 0', + '(uint64_t:1) i = 1', + '(uint64_t:1) j = 0', + '(uint64_t:1) k = 1', + ]) + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/main.cpp new file mode 100644 index 00000000000..e43bf8c138e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bitfields/main.cpp @@ -0,0 +1,81 @@ +#include <stdint.h> + +int main(int argc, char const *argv[]) { + struct LargeBitsA { + unsigned int : 30, a : 20; + } lba; + + struct LargeBitsB { + unsigned int a : 1, : 11, : 12, b : 20; + } lbb; + + struct LargeBitsC { + unsigned int : 13, : 9, a : 1, b : 1, c : 5, d : 1, e : 20; + } lbc; + + struct LargeBitsD { + char arr[3]; + unsigned int : 30, a : 20; + } lbd; + + // This case came up when debugging clang and models RecordDeclBits + struct BitExampleFromClangDeclContext { + class fields { + uint64_t : 13; + uint64_t : 9; + + uint64_t a: 1; + uint64_t b: 1; + uint64_t c: 1; + uint64_t d: 1; + uint64_t e: 1; + uint64_t f: 1; + uint64_t g: 1; + uint64_t h: 1; + uint64_t i: 1; + uint64_t j: 1; + uint64_t k: 1; + + // In order to reproduce the crash for this case we need the + // members of fields to stay private :-( + friend struct BitExampleFromClangDeclContext; + }; + + union { + struct fields f; + }; + + BitExampleFromClangDeclContext() { + f.a = 1; + f.b = 0; + f.c = 1; + f.d = 0; + f.e = 1; + f.f = 0; + f.g = 1; + f.h = 0; + f.i = 1; + f.j = 0; + f.k = 1; + } + } clang_example; + + lba.a = 2; + + lbb.a = 1; + lbb.b = 3; + + lbc.a = 1; + lbc.b = 0; + lbc.c = 4; + lbc.d = 1; + lbc.e = 20; + + lbd.arr[0] = 'a'; + lbd.arr[1] = 'b'; + lbd.arr[2] = '\0'; + lbd.a = 5; + + + return 0; // Set break point at this line. +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/TestCPPBool.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/TestCPPBool.py new file mode 100644 index 00000000000..27ea773c5db --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/TestCPPBool.py @@ -0,0 +1,28 @@ +""" +Tests that bool types work +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class CPPBoolTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_with_run_command(self): + """Test that bool types work in the expression parser""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + line = line_number('main.cpp', '// breakpoint 1') + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) + + self.runCmd("process launch", RUN_SUCCEEDED) + + self.expect("expression -- bool second_bool = my_bool; second_bool", + startstr="(bool) $0 = false") + + self.expect("expression -- my_bool = true", + startstr="(bool) $1 = true") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/main.cpp new file mode 100644 index 00000000000..a14cc690da7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/bool/main.cpp @@ -0,0 +1,16 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +int main() +{ + bool my_bool = false; + + printf("%s\n", my_bool ? "true" : "false"); // breakpoint 1 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/Makefile new file mode 100644 index 00000000000..6afea39f81c --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := nested.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py new file mode 100644 index 00000000000..32c974810f7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py @@ -0,0 +1,83 @@ +""" +Test lldb breakpoint command for CPP methods & functions in a namespace. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CPPBreakpointCommandsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def make_breakpoint(self, name, type, expected_num_locations): + bkpt = self.target.BreakpointCreateByName(name, + type, + self.a_out_module, + self.nested_comp_unit) + num_locations = bkpt.GetNumLocations() + self.assertTrue( + num_locations == expected_num_locations, + "Wrong number of locations for '%s', expected: %d got: %d" % + (name, + expected_num_locations, + num_locations)) + return bkpt + + def test_cpp_breakpoint_cmds(self): + """Test a sequence of breakpoint command add, list, and delete.""" + self.build() + + exe = self.getBuildArtifact("a.out") + + # Create a target from the debugger. + + self.target = self.dbg.CreateTarget(exe) + self.assertTrue(self.target, VALID_TARGET) + + self.a_out_module = lldb.SBFileSpecList() + self.a_out_module.Append(lldb.SBFileSpec(exe)) + + self.nested_comp_unit = lldb.SBFileSpecList() + self.nested_comp_unit.Append(lldb.SBFileSpec("nested.cpp")) + + # First provide ONLY the method name. This should get everybody... + self.make_breakpoint("Function", + lldb.eFunctionNameTypeAuto, + 5) + + # Now add the Baz class specifier. This should get the version contained in Bar, + # AND the one contained in :: + self.make_breakpoint("Baz::Function", + lldb.eFunctionNameTypeAuto, + 2) + + # Then add the Bar::Baz specifier. This should get the version + # contained in Bar only + self.make_breakpoint("Bar::Baz::Function", + lldb.eFunctionNameTypeAuto, + 1) + + self.make_breakpoint("Function", + lldb.eFunctionNameTypeMethod, + 3) + + self.make_breakpoint("Baz::Function", + lldb.eFunctionNameTypeMethod, + 2) + + self.make_breakpoint("Bar::Baz::Function", + lldb.eFunctionNameTypeMethod, + 1) + + self.make_breakpoint("Function", + lldb.eFunctionNameTypeBase, + 2) + + self.make_breakpoint("Bar::Function", + lldb.eFunctionNameTypeBase, + 1) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp new file mode 100644 index 00000000000..740649622ca --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp @@ -0,0 +1,76 @@ +#include <stdio.h> + +namespace Foo +{ + namespace Bar + { + class Baz + { + public: + Baz (int value):m_value(value) {} + int Function () + { + printf ("%s returning: %d.\n", __FUNCTION__, m_value); + return m_value + 1; + } + private: + int m_value; + }; + + class Baz2 + { + public: + Baz2 (int value):m_value(value) {} + int Function () + { + printf ("%s returning: %d.\n", __FUNCTION__, m_value); + return m_value + 2; + } + private: + int m_value; + }; + + static int bar_value = 20; + int Function () + { + printf ("%s returning: %d.\n", __FUNCTION__, bar_value); + return bar_value + 3; + } + } +} + +class Baz +{ +public: + Baz (int value):m_value(value) {} + int Function () + { + printf ("%s returning: %d.\n", __FUNCTION__, m_value); + return m_value + 4; + } +private: + int m_value; +}; + +int +Function () +{ + printf ("I am a global function, I return 333.\n"); + return 333; +} + +int main () +{ + Foo::Bar::Baz mine(200); + Foo::Bar::Baz2 mine2(300); + ::Baz bare_baz (500); + + printf ("Yup, got %d from Baz.\n", mine.Function()); + printf ("Yup, got %d from Baz.\n", mine2.Function()); + printf ("Yup, got %d from Baz.\n", bare_baz.Function()); + printf ("And got %d from Bar.\n", Foo::Bar::Function()); + printf ("And got %d from ::.\n", ::Function()); + + return 0; + +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/Makefile new file mode 100644 index 00000000000..dc53622129f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/Makefile @@ -0,0 +1,4 @@ +CXX_SOURCES = main.cpp a.cpp +CFLAGS_EXTRAS = $(MANDATORY_CXXMODULE_BUILD_CFLAGS) + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/TestBreakpointInMemberFuncWNonPrimitiveParams.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/TestBreakpointInMemberFuncWNonPrimitiveParams.py new file mode 100644 index 00000000000..1e46f73cb29 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/TestBreakpointInMemberFuncWNonPrimitiveParams.py @@ -0,0 +1,26 @@ +""" +This is a regression test for an assert that happens while setting a breakpoint. +The root cause of the assert was attempting to add a ParmVarDecl to a CXXRecordDecl +when it should have been added to a CXXMethodDecl. + +We can reproduce with a module build and setting a breakpoint in a member function +of a class with a non-primitive type as a parameter. +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + +class TestBreakpointInMemberFuncWNonPrimitiveParams(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @add_test_categories(["gmodules"]) + def test_breakpint_in_member_func_w_non_primitie_params(self): + self.build() + + (self.target, self.process, _, bkpt) = lldbutil.run_to_source_breakpoint(self, '// break here', + lldb.SBFileSpec("main.cpp", False)) + + self.runCmd("b a.cpp:11"); diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/a.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/a.cpp new file mode 100644 index 00000000000..64e142c5379 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/a.cpp @@ -0,0 +1,14 @@ +#include "a.h" + +bool A::b(int x) { + if (x) + return true; + + return false; +} + +bool B::member_func_a(A a) { + return a.b(10); // We will try and add a breakpoint here which + // trigger an assert since we will attempt to + // to add ParamVarDecl a to CXXRecordDecl A +}; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/a.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/a.h new file mode 100644 index 00000000000..cb31d3efe8f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/a.h @@ -0,0 +1,7 @@ +struct A { + bool b(int x); +}; + +struct B { + bool member_func_a(A a); +}; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/main.cpp new file mode 100644 index 00000000000..779ef04072b --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/main.cpp @@ -0,0 +1,15 @@ +#include "a.h" +#include <cstdio> + +bool foo() { + A a1; + B b1; + + return b1.member_func_a(a1); // break here +} + +int main() { + int x = 0; + + return foo(); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/module.modulemap b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/module.modulemap new file mode 100644 index 00000000000..bbd9d674c94 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/breakpoint_in_member_func_w_non_primitive_params/module.modulemap @@ -0,0 +1,3 @@ +module A { + header "a.h" +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py new file mode 100644 index 00000000000..b6274b3d266 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py @@ -0,0 +1,35 @@ +""" +Tests calling a function by basename +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CallCPPFunctionTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + TestBase.setUp(self) + self.line = line_number('main.cpp', '// breakpoint') + + def test_with_run_command(self): + """Test calling a function by basename""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("process launch", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", + STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', 'stop reason = breakpoint']) + + self.expect("expression -- a_function_to_call()", + startstr="(int) $0 = 0") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/main.cpp new file mode 100644 index 00000000000..61a5e9d21ab --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/call-function/main.cpp @@ -0,0 +1,11 @@ +#include <stdio.h> + +int a_function_to_call() +{ + return 0; +} + +int main() +{ + printf("%d\n", a_function_to_call()); // breakpoint +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py new file mode 100644 index 00000000000..080c051de98 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py @@ -0,0 +1,99 @@ +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestCppChainedCalls(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_with_run_command(self): + self.build() + + # Get main source file + src_file = "main.cpp" + src_file_spec = lldb.SBFileSpec(src_file) + self.assertTrue(src_file_spec.IsValid(), "Main source file") + + # Get the path of the executable + exe_path = self.getBuildArtifact("a.out") + + # Load the executable + target = self.dbg.CreateTarget(exe_path) + self.assertTrue(target.IsValid(), VALID_TARGET) + + # Break on main function + main_breakpoint = target.BreakpointCreateBySourceRegex( + "break here", src_file_spec) + self.assertTrue( + main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + args = None + env = None + process = target.LaunchSimple( + args, env, self.get_process_working_directory()) + self.assertTrue(process.IsValid(), PROCESS_IS_VALID) + + # Get the thread of the process + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + + # Get frame for current thread + frame = thread.GetSelectedFrame() + + # Test chained calls + test_result = frame.EvaluateExpression("get(set(true))") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "true", + "get(set(true)) = true") + + test_result = frame.EvaluateExpression("get(set(false))") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "get(set(false)) = false") + + test_result = frame.EvaluateExpression("get(t & f)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "get(t & f) = false") + + test_result = frame.EvaluateExpression("get(f & t)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "get(f & t) = false") + + test_result = frame.EvaluateExpression("get(t & t)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "true", + "get(t & t) = true") + + test_result = frame.EvaluateExpression("get(f & f)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "get(f & f) = false") + + test_result = frame.EvaluateExpression("get(t & f)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "get(t & f) = false") + + test_result = frame.EvaluateExpression("get(f) && get(t)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "get(f) && get(t) = false") + + test_result = frame.EvaluateExpression("get(f) && get(f)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "get(f) && get(t) = false") + + test_result = frame.EvaluateExpression("get(t) && get(t)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "true", + "get(t) && get(t) = true") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/main.cpp new file mode 100644 index 00000000000..a888c3f6c55 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/chained-calls/main.cpp @@ -0,0 +1,33 @@ +class Bool { +public: + Bool operator&(const Bool other) + { + Bool result; + result.value = value && other.value; + return result; + } + + bool value; +}; + +bool get(Bool object) +{ + return object.value; +} + +Bool set(bool value) +{ + Bool result; + result.value = value; + return result; +} + +int main() +{ + Bool t = set(true); + Bool f = set(false); + get(t); + get(f); + get(t & f); + return 0; // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/.categories b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/.categories new file mode 100644 index 00000000000..fe1da0247c6 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/.categories @@ -0,0 +1 @@ +dataformatters diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/Makefile new file mode 100644 index 00000000000..64fd6effcee --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/Makefile @@ -0,0 +1,6 @@ +CXX_SOURCES := main.cpp +CFLAGS :=-g -O0 -std=c++11 + +clean: OBJECTS+=$(wildcard main.d.*) + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/TestChar1632T.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/TestChar1632T.py new file mode 100644 index 00000000000..986d9e59cdf --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/TestChar1632T.py @@ -0,0 +1,119 @@ +# coding=utf8 +""" +Test that the C++11 support for char16_t and char32_t works correctly. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class Char1632TestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break for main.cpp. + self.source = 'main.cpp' + self.lines = [line_number(self.source, '// breakpoint1'), + line_number(self.source, '// breakpoint2')] + + @expectedFailureAll( + compiler="icc", + bugnumber="ICC (13.1) does not emit the DW_TAG_base_type for char16_t and char32_t.") + def test(self): + """Test that the C++11 support for char16_t and char32_t works correctly.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Set breakpoints + for line in self.lines: + lldbutil.run_break_set_by_file_and_line(self, "main.cpp", line) + + # Now launch the process, and do not stop at entry point and stop at + # breakpoint1 + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + if not process: + self.fail("SBTarget.Launch() failed") + + if self.TraceOn(): + self.runCmd("frame variable") + + # Check that we correctly report the const types + self.expect( + "frame variable cs16 cs32", + substrs=[ + '(const char16_t *) cs16 = ', + '(const char32_t *) cs32 = ', + 'u"hello world ྒྙྐ"', + 'U"hello world ྒྙྐ"']) + + # Check that we correctly report the non-const types + self.expect( + "frame variable s16 s32", + substrs=[ + '(char16_t *) s16 = ', + '(char32_t *) s32 = ', + 'u"ﺸﺵۻ"', + 'U"ЕЙРГЖО"']) + + # Check that we correctly report the array types + self.expect( + "frame variable as16 as32", + patterns=[ + '\(char16_t \[[0-9]+\]\) as16 = ', + '\(char32_t \[[0-9]+\]\) as32 = '], + substrs=[ + 'u"ﺸﺵۻ"', + 'U"ЕЙРГЖО"']) + + self.runCmd("next") # step to after the string is nullified + + # check that we don't crash on NULL + self.expect("frame variable s32", + substrs=['(char32_t *) s32 = 0x00000000']) + + # continue and hit breakpoint2 + self.runCmd("continue") + + # check that the new strings show + self.expect( + "frame variable s16 s32", + substrs=[ + '(char16_t *) s16 = 0x', + '(char32_t *) s32 = ', + '"色ハ匂ヘト散リヌルヲ"', + '"෴"']) + + # check the same as above for arrays + self.expect( + "frame variable as16 as32", + patterns=[ + '\(char16_t \[[0-9]+\]\) as16 = ', + '\(char32_t \[[0-9]+\]\) as32 = '], + substrs=[ + '"色ハ匂ヘト散リヌルヲ"', + '"෴"']) + + # check that zero values are properly handles + self.expect('frame variable cs16_zero', substrs=["U+0000 u'\\0'"]) + self.expect( + 'frame variable cs32_zero', + substrs=["U+0x00000000 U'\\0'"]) + self.expect('expression cs16_zero', substrs=["U+0000 u'\\0'"]) + self.expect('expression cs32_zero', substrs=["U+0x00000000 U'\\0'"]) + + # Check that we can run expressions that return charN_t + self.expect("expression u'a'", substrs=['(char16_t) $', "61 u'a'"]) + self.expect("expression U'a'", substrs=['(char32_t) $', "61 U'a'"]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/main.cpp new file mode 100644 index 00000000000..8cd0cfc77c5 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char1632_t/main.cpp @@ -0,0 +1,43 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <assert.h> +#include <string> + +#define UASZ 64 + +template<class T, int N> +void copy_char_seq (T (&arr)[N], const T* src) +{ + size_t src_len = std::char_traits<T>::length(src); + assert(src_len < N); + + std::char_traits<T>::copy(arr, src, src_len); + arr[src_len] = 0; +} + +int main (int argc, char const *argv[]) +{ + char16_t as16[UASZ]; + char32_t as32[UASZ]; + auto cs16_zero = (char16_t)0; + auto cs32_zero = (char32_t)0; + auto cs16 = u"hello world ྒྙྐ"; + auto cs32 = U"hello world ྒྙྐ"; + char16_t *s16 = (char16_t *)u"ﺸﺵۻ"; + char32_t *s32 = (char32_t *)U"ЕЙРГЖО"; + copy_char_seq(as16, s16); + copy_char_seq(as32, s32); + s32 = nullptr; // breakpoint1 + s32 = (char32_t *)U"෴"; + s16 = (char16_t *)u"色ハ匂ヘト散リヌルヲ"; + copy_char_seq(as16, s16); + copy_char_seq(as32, s32); + s32 = nullptr; // breakpoint2 + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/Makefile new file mode 100644 index 00000000000..e7c9938b5a8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/Makefile @@ -0,0 +1,4 @@ +CXX_SOURCES := main.cpp +CXXFLAGS_EXTRAS := -std=c++2a -fchar8_t + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/TestCxxChar8_t.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/TestCxxChar8_t.py new file mode 100644 index 00000000000..e7f2c1afbdd --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/TestCxxChar8_t.py @@ -0,0 +1,39 @@ +# coding=utf8 +""" +Test that C++ supports char8_t correctly. +""" + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class CxxChar8_tTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipIf(compiler="clang", compiler_version=['<', '7.0']) + def test(self): + """Test that C++ supports char8_t correctly.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # FIXME: We should be able to test this with target variable, but the + # data formatter output is broken. + lldbutil.run_break_set_by_symbol(self, 'main') + self.runCmd("run", RUN_SUCCEEDED) + + self.expect( + "frame variable a", substrs=["(char8_t)", "0x61 u8'a'"]) + + self.expect( + "frame variable ab", substrs=['(const char8_t *)' , 'u8"你好"']) + + self.expect( + "frame variable abc", substrs=['(char8_t [9])', 'u8"你好"']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/main.cpp new file mode 100644 index 00000000000..b73ba0c4e61 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/char8_t/main.cpp @@ -0,0 +1,5 @@ +char8_t a = u8'a'; +const char8_t* ab = u8"你好"; +char8_t abc[9] = u8"你好"; + +int main (int argc, char const *argv[]) { return 0; } diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/TestClassTemplateParameterPack.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/TestClassTemplateParameterPack.py new file mode 100644 index 00000000000..7e67f73b709 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/TestClassTemplateParameterPack.py @@ -0,0 +1,7 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest( + __file__, globals(), [ + decorators.expectedFailureAll( + compiler="gcc")]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/main.cpp new file mode 100644 index 00000000000..9278d01f8c5 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class-template-parameter-pack/main.cpp @@ -0,0 +1,64 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +template <class T, int... Args> struct C { + T member; + bool isSixteenThirtyTwo() { return false; } +}; + +template <> struct C<int, 16> { + int member; + bool isSixteenThirtyTwo() { return false; } +}; + +template <> struct C<int, 16, 32> : C<int, 16> { + bool isSixteenThirtyTwo() { return true; } +}; + +template <class T, typename... Args> struct D { + T member; + bool isIntBool() { return false; } +}; + +template <> struct D<int, int> { + int member; + bool isIntBool() { return false; } +}; + +template <> struct D<int, int, bool> : D<int, int> { + bool isIntBool() { return true; } +}; + +int main (int argc, char const *argv[]) +{ + C<int,16,32> myC; + C<int,16> myLesserC; + myC.member = 64; + (void)C<int,16,32>().isSixteenThirtyTwo(); + (void)C<int,16>().isSixteenThirtyTwo(); + (void)(myC.member != 64); //% self.expect("expression -- myC", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["64"]) + //% self.expect("expression -- myLesserC.isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"]) + //% self.expect("expression -- myC.isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"]) + + // Disabling until we do template lookup correctly: http://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180507/040689.html + //#% self.expect("expression -- C<int, 16>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"]) + //#% self.expect("expression -- C<int, 16, 32>().isSixteenThirtyTwo()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"]) + + D<int,int,bool> myD; + D<int,int> myLesserD; + myD.member = 64; + (void)D<int,int,bool>().isIntBool(); + (void)D<int,int>().isIntBool(); + return myD.member != 64; //% self.expect("expression -- myD", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["64"]) + //% self.expect("expression -- myLesserD.isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"]) + //% self.expect("expression -- myD.isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"]) + + // See comment above. + //#% self.expect("expression -- D<int, int>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["false"]) + //#% self.expect("expression -- D<int, int, bool>().isIntBool()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["true"]) +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py new file mode 100644 index 00000000000..7c019e0e7cf --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py @@ -0,0 +1,173 @@ +""" +Test display and Python APIs on file and class static variables. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class StaticVariableTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break at. + self.line = line_number('main.cpp', '// Set break point at this line.') + + def test_with_run_command(self): + """Test that file and class static variables display correctly.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("run", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # Global variables are no longer displayed with the "frame variable" + # command. + self.expect( + 'target variable A::g_points', + VARIABLES_DISPLAYED_CORRECTLY, + patterns=['\(PointType \[[1-9]*\]\) A::g_points = {']) + self.expect('target variable g_points', VARIABLES_DISPLAYED_CORRECTLY, + substrs=['(PointType [2]) g_points']) + + # On Mac OS X, gcc 4.2 emits the wrong debug info for A::g_points. + # A::g_points is an array of two elements. + if self.platformIsDarwin() or self.getPlatform() == "linux": + self.expect( + "target variable A::g_points[1].x", + VARIABLES_DISPLAYED_CORRECTLY, + startstr="(int) A::g_points[1].x = 11") + + @expectedFailureAll( + compiler=["gcc"], + bugnumber="Compiler emits incomplete debug info") + @expectedFailureAll( + compiler=["clang"], + compiler_version=["<", "3.9"], + bugnumber='llvm.org/pr20550') + def test_with_run_command_complete(self): + """ + Test that file and class static variables display correctly with + complete debug information. + """ + self.build() + target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) + self.assertTrue(target, VALID_TARGET) + + # Global variables are no longer displayed with the "frame variable" + # command. + self.expect( + 'target variable A::g_points', + VARIABLES_DISPLAYED_CORRECTLY, + patterns=[ + '\(PointType \[[1-9]*\]\) A::g_points = {', '(x = 1, y = 2)', + '(x = 11, y = 22)' + ]) + + # Ensure that we take the context into account and only print + # A::g_points. + self.expect( + 'target variable A::g_points', + VARIABLES_DISPLAYED_CORRECTLY, + matching=False, + patterns=['(x = 3, y = 4)', '(x = 33, y = 44)']) + + # Finally, ensure that we print both points when not specifying a + # context. + self.expect( + 'target variable g_points', + VARIABLES_DISPLAYED_CORRECTLY, + substrs=[ + '(PointType [2]) g_points', '(x = 1, y = 2)', + '(x = 11, y = 22)', '(x = 3, y = 4)', '(x = 33, y = 44)' + ]) + + @expectedFailureAll( + compiler=["gcc"], + bugnumber="Compiler emits incomplete debug info") + @expectedFailureAll( + compiler=["clang"], + compiler_version=["<", "3.9"], + bugnumber='llvm.org/pr20550') + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") + @add_test_categories(['pyapi']) + def test_with_python_api(self): + """Test Python APIs on file and class static variables.""" + self.build() + exe = self.getBuildArtifact("a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line) + self.assertTrue(breakpoint, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + + # Get the SBValue of 'A::g_points' and 'g_points'. + frame = thread.GetFrameAtIndex(0) + + # arguments => False + # locals => False + # statics => True + # in_scope_only => False + valList = frame.GetVariables(False, False, True, False) + + for val in valList: + self.DebugSBValue(val) + name = val.GetName() + self.assertTrue(name in ['g_points', 'A::g_points']) + if name == 'g_points': + self.assertTrue( + val.GetValueType() == lldb.eValueTypeVariableStatic) + self.assertEqual(val.GetNumChildren(), 2) + elif name == 'A::g_points': + self.assertTrue( + val.GetValueType() == lldb.eValueTypeVariableGlobal) + self.assertEqual(val.GetNumChildren(), 2) + child1 = val.GetChildAtIndex(1) + self.DebugSBValue(child1) + child1_x = child1.GetChildAtIndex(0) + self.DebugSBValue(child1_x) + self.assertTrue(child1_x.GetTypeName() == 'int' and + child1_x.GetValue() == '11') + + # SBFrame.FindValue() should also work. + val = frame.FindValue("A::g_points", lldb.eValueTypeVariableGlobal) + self.DebugSBValue(val) + self.assertTrue(val.GetName() == 'A::g_points') + + # Also exercise the "parameter" and "local" scopes while we are at it. + val = frame.FindValue("argc", lldb.eValueTypeVariableArgument) + self.DebugSBValue(val) + self.assertTrue(val.GetName() == 'argc') + + val = frame.FindValue("argv", lldb.eValueTypeVariableArgument) + self.DebugSBValue(val) + self.assertTrue(val.GetName() == 'argv') + + val = frame.FindValue("hello_world", lldb.eValueTypeVariableLocal) + self.DebugSBValue(val) + self.assertTrue(val.GetName() == 'hello_world') diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/main.cpp new file mode 100644 index 00000000000..319a05a7bee --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_static/main.cpp @@ -0,0 +1,52 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// I made this example after noting that I was unable to display an unsized +// static class array. It turns out that gcc 4.2 will emit DWARF that correctly +// describes the PointType, but it will incorrectly emit debug info for the +// "g_points" array where the following things are wrong: +// - the DW_TAG_array_type won't have a subrange info +// - the DW_TAG_variable for "g_points" won't have a valid byte size, so even +// though we know the size of PointType, we can't infer the actual size +// of the array by dividing the size of the variable by the number of +// elements. + +#include <stdio.h> + +typedef struct PointType +{ + int x, y; +} PointType; + +class A +{ +public: + static PointType g_points[]; +}; + +PointType A::g_points[] = +{ + { 1, 2 }, + { 11, 22 } +}; + +static PointType g_points[] = +{ + { 3, 4 }, + { 33, 44 } +}; + +int +main (int argc, char const *argv[]) +{ + const char *hello_world = "Hello, world!"; + printf ("A::g_points[1].x = %i\n", A::g_points[1].x); // Set break point at this line. + printf ("::g_points[1].x = %i\n", g_points[1].x); + printf ("%s\n", hello_world); + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py new file mode 100644 index 00000000000..45d64431ab3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py @@ -0,0 +1,224 @@ +"""Test breakpoint on a class constructor; and variable list the this object.""" + + + +import os +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class ClassTypesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break for main.cpp. + self.line = line_number('main.cpp', '// Set break point at this line.') + + def test_with_run_command(self): + """Test 'frame variable this' when stopped on a class constructor.""" + self.build() + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # Break on the ctor function of class C. + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=-1) + + self.runCmd("run", RUN_SUCCEEDED) + + # The test suite sometimes shows that the process has exited without stopping. + # + # CC=clang ./dotest.py -v -t class_types + # ... + # Process 76604 exited with status = 0 (0x00000000) + self.runCmd("process status") + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) + + # We should be stopped on the ctor function of class C. + self.expect( + "frame variable --show-types this", + VARIABLES_DISPLAYED_CORRECTLY, + substrs=[ + 'C *', + ' this = ']) + + @add_test_categories(['pyapi']) + def test_with_python_api(self): + """Use Python APIs to create a breakpoint by (filespec, line).""" + self.build() + exe = self.getBuildArtifact("a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + filespec = target.GetExecutable() + self.assertTrue(filespec, VALID_FILESPEC) + + fsDir = os.path.normpath(filespec.GetDirectory()) + fsFile = filespec.GetFilename() + + self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact()) + and fsFile == "a.out", + "FileSpec matches the executable") + + bpfilespec = lldb.SBFileSpec("main.cpp", False) + + breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line) + self.assertTrue(breakpoint, VALID_BREAKPOINT) + + # Verify the breakpoint just created. + self.expect(str(breakpoint), BREAKPOINT_CREATED, exe=False, + substrs=['main.cpp', + str(self.line)]) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + if not process: + self.fail("SBTarget.Launch() failed") + + if process.GetState() != lldb.eStateStopped: + self.fail("Process should be in the 'stopped' state, " + "instead the actual state is: '%s'" % + lldbutil.state_type_to_str(process.GetState())) + + # The stop reason of the thread should be breakpoint. + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + + # The filename of frame #0 should be 'main.cpp' and the line number + # should be 93. + self.expect("%s:%d" % (lldbutil.get_filenames(thread)[0], + lldbutil.get_line_numbers(thread)[0]), + "Break correctly at main.cpp:%d" % self.line, exe=False, + startstr="main.cpp:") + # clang compiled code reported main.cpp:94? + # startstr = "main.cpp:93") + + # We should be stopped on the breakpoint with a hit count of 1. + self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE) + + process.Continue() + + def test_with_expr_parser(self): + """Test 'frame variable this' and 'expr this' when stopped inside a constructor.""" + self.build() + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # rdar://problem/8516141 + # Is this a case of clang (116.1) generating bad debug info? + # + # Break on the ctor function of class C. + # self.expect("breakpoint set -M C", BREAKPOINT_CREATED, + # startstr = "Breakpoint created: 1: name = 'C'") + + # Make the test case more robust by using line number to break, + # instead. + lldbutil.run_break_set_by_file_and_line( + self, None, self.line, num_expected_locations=-1) + + self.runCmd("run", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) + + # Continue on inside the ctor() body... + self.runCmd("register read pc") + self.runCmd("thread step-over") + + # Verify that 'frame variable this' gets the data type correct. + self.expect("frame variable this", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['C *']) + + # Verify that frame variable --show-types this->m_c_int behaves + # correctly. + self.runCmd("register read pc") + self.runCmd("expr m_c_int") + self.expect( + "frame variable --show-types this->m_c_int", + VARIABLES_DISPLAYED_CORRECTLY, + startstr='(int) this->m_c_int = 66') + + # Verify that 'expression this' gets the data type correct. + self.expect("expression this", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['C *']) + + # rdar://problem/8430916 + # expr this->m_c_int returns an incorrect value + # + # Verify that expr this->m_c_int behaves correctly. + self.expect("expression this->m_c_int", VARIABLES_DISPLAYED_CORRECTLY, + patterns=['\(int\) \$[0-9]+ = 66']) + + def test_with_constructor_name(self): + """Test 'frame variable this' and 'expr this' when stopped inside a constructor.""" + self.build() + exe = self.getBuildArtifact("a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + filespec = target.GetExecutable() + self.assertTrue(filespec, VALID_FILESPEC) + + fsDir = os.path.normpath(filespec.GetDirectory()) + fsFile = filespec.GetFilename() + + self.assertTrue(fsDir == os.path.dirname(self.getBuildArtifact()) + and fsFile == "a.out", + "FileSpec matches the executable") + + bpfilespec = lldb.SBFileSpec("main.cpp", False) + + breakpoint = target.BreakpointCreateByLocation(bpfilespec, self.line) + self.assertTrue(breakpoint, VALID_BREAKPOINT) + + # Verify the breakpoint just created. + self.expect(str(breakpoint), BREAKPOINT_CREATED, exe=False, + substrs=['main.cpp', + str(self.line)]) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + if not process: + self.fail("SBTarget.Launch() failed") + + if process.GetState() != lldb.eStateStopped: + self.fail("Process should be in the 'stopped' state, " + "instead the actual state is: '%s'" % + lldbutil.state_type_to_str(process.GetState())) + + # The stop reason of the thread should be breakpoint. + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + + frame = thread.frames[0] + self.assertTrue(frame.IsValid(), "Got a valid frame.") + + self.assertTrue("C::C" in frame.name, + "Constructor name includes class name.") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py new file mode 100644 index 00000000000..ad187d0394b --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py @@ -0,0 +1,99 @@ +""" +Test the lldb disassemble command on each call frame when stopped on C's ctor. +""" + +from __future__ import print_function + + +import os +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class IterateFrameAndDisassembleTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_and_run_command(self): + """Disassemble each call frame when stopped on C's constructor.""" + self.build() + self.breakOnCtor() + + raw_output = self.res.GetOutput() + frameRE = re.compile(r""" + ^\s\sframe # heading for the frame info, + .* # wildcard, and + 0x[0-9a-f]{16} # the frame pc, and + \sa.out`(.+) # module`function, and + \s\+\s # the rest ' + ....' + """, re.VERBOSE) + for line in raw_output.split(os.linesep): + match = frameRE.search(line) + if match: + function = match.group(1) + #print("line:", line) + #print("function:", function) + self.runCmd("disassemble -n '%s'" % function) + + @add_test_categories(['pyapi']) + def test_and_python_api(self): + """Disassemble each call frame when stopped on C's constructor.""" + self.build() + self.breakOnCtor() + + # Now use the Python API to get at each function on the call stack and + # disassemble it. + target = self.dbg.GetSelectedTarget() + process = target.GetProcess() + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + depth = thread.GetNumFrames() + for i in range(depth - 1): + frame = thread.GetFrameAtIndex(i) + function = frame.GetFunction() + # Print the function header. + if self.TraceOn(): + print() + print(function) + if function: + # Get all instructions for this function and print them out. + insts = function.GetInstructions(target) + for inst in insts: + # We could simply do 'print inst' to print out the disassembly. + # But we want to print to stdout only if self.TraceOn() is + # True. + disasm = str(inst) + if self.TraceOn(): + print(disasm) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break for main.cpp. + self.line = line_number('main.cpp', '// Set break point at this line.') + + def breakOnCtor(self): + """Setup/run the program so it stops on C's constructor.""" + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # Break on the ctor function of class C. + bpno = lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=-1) + + self.runCmd("run", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint %d.' % (bpno)]) + + # This test was failing because we fail to put the C:: in front of constructore. + # We should maybe make another testcase to cover that specifically, but we shouldn't + # fail this whole testcase for an inessential issue. + # We should be stopped on the ctor function of class C. + # self.expect("thread backtrace", BACKTRACE_DISPLAYED_CORRECTLY, + # substrs = ['C::C']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/cmds.txt b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/cmds.txt new file mode 100644 index 00000000000..1c7ef9f1c8a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/cmds.txt @@ -0,0 +1,3 @@ +b main.cpp:97 +c +var diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/main.cpp new file mode 100644 index 00000000000..179f2177793 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/class_types/main.cpp @@ -0,0 +1,125 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +class Conversion +{ +public: + Conversion (int i) : + m_i (i) + {} + + operator bool() + { + return m_i != 0; + } + +private: + int m_i; +}; + +class A +{ +public: + A(int i=0): + m_a_int(i), + m_aa_int(i+1) + { + } + + //virtual + ~A() + { + } + + int + GetInteger() const + { + return m_a_int; + } + void + SetInteger(int i) + { + m_a_int = i; + } + +protected: + int m_a_int; + int m_aa_int; +}; + +class B : public A +{ +public: + B(int ai, int bi) : + A(ai), + m_b_int(bi) + { + } + + //virtual + ~B() + { + } + + int + GetIntegerB() const + { + return m_b_int; + } + void + SetIntegerB(int i) + { + m_b_int = i; + } + +protected: + int m_b_int; +}; + +#include <cstdio> +class C : public B +{ +public: + C(int ai, int bi, int ci) : + B(ai, bi), + m_c_int(ci) + { + std::printf("Within C::ctor() m_c_int=%d\n", m_c_int); // Set break point at this line. + } + + //virtual + ~C() + { + } + + int + GetIntegerC() const + { + return m_c_int; + } + void + SetIntegerC(int i) + { + m_c_int = i; + } + +protected: + int m_c_int; +}; + +int +main (int argc, char const *argv[]) +{ + A a(12); + B b(22,33); + C c(44,55,66); + Conversion conv(1); + if (conv) + return b.GetIntegerB() - a.GetInteger() + c.GetInteger(); + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/const_this/TestConstThis.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/const_this/TestConstThis.py new file mode 100644 index 00000000000..f08c0dcbda9 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/const_this/TestConstThis.py @@ -0,0 +1,4 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals(), []) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/const_this/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/const_this/main.cpp new file mode 100644 index 00000000000..c244e1bf44e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/const_this/main.cpp @@ -0,0 +1,22 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +class foo { +public: + template <class T> T func(T x) const { + return x+2; //% self.expect("expr 2+3", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["5"]) + } +}; + +int i; + +int main() { + return foo().func(i); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py new file mode 100644 index 00000000000..c1d0d236268 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py @@ -0,0 +1,51 @@ +""" +Tests that bool types work +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class CPPTestDiamondInheritance(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_with_run_command(self): + """Test that virtual base classes work in when SBValue objects are used to explore the variable value""" + self.build() + exe = self.getBuildArtifact("a.out") + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) + self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + frame = thread.GetFrameAtIndex(0) + j1 = frame.FindVariable("j1") + j1_Derived1 = j1.GetChildAtIndex(0) + j1_Derived2 = j1.GetChildAtIndex(1) + j1_Derived1_VBase = j1_Derived1.GetChildAtIndex(0) + j1_Derived2_VBase = j1_Derived2.GetChildAtIndex(0) + j1_Derived1_VBase_m_value = j1_Derived1_VBase.GetChildAtIndex(0) + j1_Derived2_VBase_m_value = j1_Derived2_VBase.GetChildAtIndex(0) + self.assertTrue( + j1_Derived1_VBase.GetLoadAddress() == j1_Derived2_VBase.GetLoadAddress(), + "ensure virtual base class is the same between Derived1 and Derived2") + self.assertTrue(j1_Derived1_VBase_m_value.GetValueAsUnsigned( + 1) == j1_Derived2_VBase_m_value.GetValueAsUnsigned(2), "ensure m_value in VBase is the same") + self.assertTrue(frame.FindVariable("d").GetChildAtIndex(0).GetChildAtIndex( + 0).GetValueAsUnsigned(0) == 12345, "ensure Derived2 from j1 is correct") + thread.StepOver() + self.assertTrue(frame.FindVariable("d").GetChildAtIndex(0).GetChildAtIndex( + 0).GetValueAsUnsigned(0) == 12346, "ensure Derived2 from j2 is correct") + + def set_breakpoint(self, line): + # Some compilers (for example GCC 4.4.7 and 4.6.1) emit multiple locations for the statement with the ternary + # operator in the test program, while others emit only 1. + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/main.cpp new file mode 100644 index 00000000000..31329b271e2 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/diamond/main.cpp @@ -0,0 +1,84 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include <stdio.h> + +static int g_next_value = 12345; + +class VBase +{ +public: + VBase() : m_value(g_next_value++) {} + virtual ~VBase() {} + void Print() + { + printf("%p: %s\n%p: m_value = 0x%8.8x\n", this, __PRETTY_FUNCTION__, &m_value, m_value); + } + int m_value; +}; + +class Derived1 : public virtual VBase +{ +public: + Derived1() {}; + void Print () + { + printf("%p: %s\n", this, __PRETTY_FUNCTION__); + VBase::Print(); + } + +}; + +class Derived2 : public virtual VBase +{ +public: + Derived2() {}; + + void Print () + { + printf("%p: %s\n", this, __PRETTY_FUNCTION__); + VBase::Print(); + } +}; + +class Joiner1 : public Derived1, public Derived2 +{ +public: + Joiner1() : + m_joiner1(3456), + m_joiner2(6789) {} + void Print () + { + printf("%p: %s \n%p: m_joiner1 = 0x%8.8x\n%p: m_joiner2 = 0x%8.8x\n", + this, + __PRETTY_FUNCTION__, + &m_joiner1, + m_joiner1, + &m_joiner2, + m_joiner2); + Derived1::Print(); + Derived2::Print(); + } + int m_joiner1; + int m_joiner2; +}; + +class Joiner2 : public Derived2 +{ + int m_stuff[32]; +}; + +int main(int argc, const char * argv[]) +{ + Joiner1 j1; + Joiner2 j2; + j1.Print(); + j2.Print(); + Derived2 *d = &j1; + d = &j2; // breakpoint 1 + return 0; // breakpoint 2 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/TestDynamicValueSameBase.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/TestDynamicValueSameBase.py new file mode 100644 index 00000000000..546fd11a1b4 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/TestDynamicValueSameBase.py @@ -0,0 +1,58 @@ +""" +Make sure if we have two classes with the same base name the +dynamic value calculator doesn't confuse them +""" + + + +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + + +class DynamicValueSameBaseTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + # If your test case doesn't stress debug info, the + # set this to true. That way it won't be run once for + # each debug info format. + NO_DEBUG_INFO_TESTCASE = True + + def test_same_basename_this(self): + """Test that the we use the full name to resolve dynamic types.""" + self.build() + self.main_source_file = lldb.SBFileSpec("main.cpp") + self.sample_test() + + def sample_test(self): + (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, + "Break here to get started", self.main_source_file) + + # Set breakpoints in the two class methods and run to them: + namesp_bkpt = target.BreakpointCreateBySourceRegex("namesp function did something.", self.main_source_file) + self.assertEqual(namesp_bkpt.GetNumLocations(), 1, "Namespace breakpoint invalid") + + virtual_bkpt = target.BreakpointCreateBySourceRegex("Virtual function did something.", self.main_source_file) + self.assertEqual(virtual_bkpt.GetNumLocations(), 1, "Virtual breakpoint invalid") + + threads = lldbutil.continue_to_breakpoint(process, namesp_bkpt) + self.assertEqual(len(threads), 1, "Didn't stop at namespace breakpoint") + + frame = threads[0].frame[0] + namesp_this = frame.FindVariable("this", lldb.eDynamicCanRunTarget) + # Clang specifies the type of this as "T *", gcc as "T * const". This + # erases the difference. + namesp_type = namesp_this.GetType().GetUnqualifiedType() + self.assertEqual(namesp_type.GetName(), "namesp::Virtual *", "Didn't get the right dynamic type") + + threads = lldbutil.continue_to_breakpoint(process, virtual_bkpt) + self.assertEqual(len(threads), 1, "Didn't stop at virtual breakpoint") + + frame = threads[0].frame[0] + virtual_this = frame.FindVariable("this", lldb.eDynamicCanRunTarget) + virtual_type = virtual_this.GetType().GetUnqualifiedType() + self.assertEqual(virtual_type.GetName(), "Virtual *", "Didn't get the right dynamic type") + + + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/main.cpp new file mode 100644 index 00000000000..38e46c03f41 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value-same-basename/main.cpp @@ -0,0 +1,32 @@ +#include <stdio.h> + +namespace namesp +{ + class Virtual { + public: + virtual void doSomething() { + printf ("namesp function did something.\n"); + } + }; +} + +class Virtual { + public: + virtual void doSomething() { + printf("Virtual function did something.\n"); + } +}; + +int +main() +{ + namesp::Virtual my_outer; + Virtual my_virtual; + + // Break here to get started + my_outer.doSomething(); + my_virtual.doSomething(); + + return 0; +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/Makefile new file mode 100644 index 00000000000..2bba8e757f7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := pass-to-base.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py new file mode 100644 index 00000000000..609dd608aa4 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py @@ -0,0 +1,135 @@ +""" +Test lldb Python API SBValue::Cast(SBType) for C++ types. +""" + +from __future__ import print_function + + +import unittest2 +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CppValueCastTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipIf(bugnumber="llvm.org/PR36714") + @add_test_categories(['pyapi']) + def test_value_cast_with_virtual_inheritance(self): + """Test SBValue::Cast(SBType) API for C++ types with virtual inheritance.""" + self.build(dictionary=self.d_virtual) + self.setTearDownCleanup(dictionary=self.d_virtual) + self.do_sbvalue_cast(self.exe_name) + + @add_test_categories(['pyapi']) + def test_value_cast_with_regular_inheritance(self): + """Test SBValue::Cast(SBType) API for C++ types with regular inheritance.""" + self.build(dictionary=self.d_regular) + self.setTearDownCleanup(dictionary=self.d_regular) + self.do_sbvalue_cast(self.exe_name) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + + # Find the line number to break for main.c. + self.source = 'sbvalue-cast.cpp' + self.line = line_number(self.source, '// Set breakpoint here.') + self.exe_name = self.testMethodName + self.d_virtual = { + 'CXX_SOURCES': self.source, + 'EXE': self.exe_name, + 'CFLAGS_EXTRAS': '-DDO_VIRTUAL_INHERITANCE'} + self.d_regular = {'CXX_SOURCES': self.source, 'EXE': self.exe_name} + + def do_sbvalue_cast(self, exe_name): + """Test SBValue::Cast(SBType) API for C++ types.""" + exe = self.getBuildArtifact(exe_name) + + # Create a target from the debugger. + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Set up our breakpoints: + + breakpoint = target.BreakpointCreateByLocation(self.source, self.line) + self.assertTrue(breakpoint, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at the entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + self.assertTrue(process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + # Find DerivedA and DerivedB types. + typeA = target.FindFirstType('DerivedA') + typeB = target.FindFirstType('DerivedB') + self.DebugSBType(typeA) + self.DebugSBType(typeB) + self.assertTrue(typeA) + self.assertTrue(typeB) + error = lldb.SBError() + + # First stop is for DerivedA instance. + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, breakpoint) + self.assertTrue(len(threads) == 1) + thread = threads[0] + frame0 = thread.GetFrameAtIndex(0) + + tellerA = frame0.FindVariable('teller', lldb.eNoDynamicValues) + self.DebugSBValue(tellerA) + self.assertTrue(tellerA.GetChildMemberWithName( + 'm_base_val').GetValueAsUnsigned(error, 0) == 20) + + if self.TraceOn(): + for child in tellerA: + print("child name:", child.GetName()) + print(child) + + # Call SBValue.Cast() to obtain instanceA. + instanceA = tellerA.Cast(typeA.GetPointerType()) + self.DebugSBValue(instanceA) + + # Iterate through all the children and print their values. + if self.TraceOn(): + for child in instanceA: + print("child name:", child.GetName()) + print(child) + a_member_val = instanceA.GetChildMemberWithName('m_a_val') + self.DebugSBValue(a_member_val) + self.assertTrue(a_member_val.GetValueAsUnsigned(error, 0) == 10) + + # Second stop is for DerivedB instance. + threads = lldbutil.continue_to_breakpoint(process, breakpoint) + self.assertTrue(len(threads) == 1) + thread = threads[0] + frame0 = thread.GetFrameAtIndex(0) + + tellerB = frame0.FindVariable('teller', lldb.eNoDynamicValues) + self.DebugSBValue(tellerB) + self.assertTrue(tellerB.GetChildMemberWithName( + 'm_base_val').GetValueAsUnsigned(error, 0) == 12) + + if self.TraceOn(): + for child in tellerB: + print("child name:", child.GetName()) + print(child) + + # Call SBValue.Cast() to obtain instanceB. + instanceB = tellerB.Cast(typeB.GetPointerType()) + self.DebugSBValue(instanceB) + + # Iterate through all the children and print their values. + if self.TraceOn(): + for child in instanceB: + print("child name:", child.GetName()) + print(child) + b_member_val = instanceB.GetChildMemberWithName('m_b_val') + self.DebugSBValue(b_member_val) + self.assertTrue(b_member_val.GetValueAsUnsigned(error, 0) == 36) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py new file mode 100644 index 00000000000..c3d7dfb328f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py @@ -0,0 +1,249 @@ +""" +Use lldb Python API to test dynamic values in C++ +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class DynamicValueTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + + # Find the line number to break for main.c. + + self.do_something_line = line_number( + 'pass-to-base.cpp', '// Break here in doSomething.') + self.main_first_call_line = line_number( + 'pass-to-base.cpp', + '// Break here and get real addresses of myB and otherB.') + self.main_second_call_line = line_number( + 'pass-to-base.cpp', '// Break here and get real address of reallyA.') + + @add_test_categories(['pyapi']) + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24663") + def test_get_dynamic_vals(self): + """Test fetching C++ dynamic values from pointers & references.""" + self.build(dictionary=self.getBuildFlags()) + exe = self.getBuildArtifact("a.out") + + # Create a target from the debugger. + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Set up our breakpoints: + + do_something_bpt = target.BreakpointCreateByLocation( + 'pass-to-base.cpp', self.do_something_line) + self.assertTrue(do_something_bpt, + VALID_BREAKPOINT) + + first_call_bpt = target.BreakpointCreateByLocation( + 'pass-to-base.cpp', self.main_first_call_line) + self.assertTrue(first_call_bpt, + VALID_BREAKPOINT) + + second_call_bpt = target.BreakpointCreateByLocation( + 'pass-to-base.cpp', self.main_second_call_line) + self.assertTrue(second_call_bpt, + VALID_BREAKPOINT) + + # Now launch the process, and do not stop at the entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + self.assertTrue(process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + threads = lldbutil.get_threads_stopped_at_breakpoint( + process, first_call_bpt) + self.assertTrue(len(threads) == 1) + thread = threads[0] + + frame = thread.GetFrameAtIndex(0) + + # Now find the dynamic addresses of myB and otherB so we can compare them + # with the dynamic values we get in doSomething: + + use_dynamic = lldb.eDynamicCanRunTarget + no_dynamic = lldb.eNoDynamicValues + + myB = frame.FindVariable('myB', no_dynamic) + self.assertTrue(myB) + myB_loc = int(myB.GetLocation(), 16) + + otherB = frame.FindVariable('otherB', no_dynamic) + self.assertTrue(otherB) + otherB_loc = int(otherB.GetLocation(), 16) + + # Okay now run to doSomething: + + threads = lldbutil.continue_to_breakpoint(process, do_something_bpt) + self.assertTrue(len(threads) == 1) + thread = threads[0] + + frame = thread.GetFrameAtIndex(0) + + # Get "this" using FindVariable: + + this_static = frame.FindVariable('this', no_dynamic) + this_dynamic = frame.FindVariable('this', use_dynamic) + self.examine_value_object_of_this_ptr( + this_static, this_dynamic, myB_loc) + + # Now make sure that the "GetDynamicValue" works: + # This doesn't work currently because we can't get dynamic values from + # ConstResult objects. + fetched_dynamic_value = this_static.GetDynamicValue(use_dynamic) + self.examine_value_object_of_this_ptr( + this_static, fetched_dynamic_value, myB_loc) + + # And conversely that the GetDynamicValue() interface also works: + fetched_static_value = this_dynamic.GetStaticValue() + self.examine_value_object_of_this_ptr( + fetched_static_value, this_dynamic, myB_loc) + + # Get "this" using FindValue, make sure that works too: + this_static = frame.FindValue( + 'this', lldb.eValueTypeVariableArgument, no_dynamic) + this_dynamic = frame.FindValue( + 'this', lldb.eValueTypeVariableArgument, use_dynamic) + self.examine_value_object_of_this_ptr( + this_static, this_dynamic, myB_loc) + + # Get "this" using the EvaluateExpression: + this_static = frame.EvaluateExpression('this', False) + this_dynamic = frame.EvaluateExpression('this', True) + self.examine_value_object_of_this_ptr( + this_static, this_dynamic, myB_loc) + + # The "frame var" code uses another path to get into children, so let's + # make sure that works as well: + + self.expect( + 'frame var -d run-target --ptr-depth=2 --show-types anotherA.m_client_A', + 'frame var finds its way into a child member', + patterns=['\(B \*\)']) + + # Now make sure we also get it right for a reference as well: + + anotherA_static = frame.FindVariable('anotherA', False) + self.assertTrue(anotherA_static) + anotherA_static_addr = int(anotherA_static.GetValue(), 16) + + anotherA_dynamic = frame.FindVariable('anotherA', True) + self.assertTrue(anotherA_dynamic) + anotherA_dynamic_addr = int(anotherA_dynamic.GetValue(), 16) + anotherA_dynamic_typename = anotherA_dynamic.GetTypeName() + self.assertTrue(anotherA_dynamic_typename.find('B') != -1) + + self.assertTrue(anotherA_dynamic_addr < anotherA_static_addr) + + anotherA_m_b_value_dynamic = anotherA_dynamic.GetChildMemberWithName( + 'm_b_value', True) + self.assertTrue(anotherA_m_b_value_dynamic) + anotherA_m_b_val = int(anotherA_m_b_value_dynamic.GetValue(), 10) + self.assertTrue(anotherA_m_b_val == 300) + + anotherA_m_b_value_static = anotherA_static.GetChildMemberWithName( + 'm_b_value', True) + self.assertFalse(anotherA_m_b_value_static) + + # Okay, now continue again, and when we hit the second breakpoint in + # main + + threads = lldbutil.continue_to_breakpoint(process, second_call_bpt) + self.assertTrue(len(threads) == 1) + thread = threads[0] + + frame = thread.GetFrameAtIndex(0) + reallyA_value = frame.FindVariable('reallyA', False) + self.assertTrue(reallyA_value) + reallyA_loc = int(reallyA_value.GetLocation(), 16) + + # Finally continue to doSomething again, and make sure we get the right value for anotherA, + # which this time around is just an "A". + + threads = lldbutil.continue_to_breakpoint(process, do_something_bpt) + self.assertTrue(len(threads) == 1) + thread = threads[0] + + frame = thread.GetFrameAtIndex(0) + anotherA_value = frame.FindVariable('anotherA', True) + self.assertTrue(anotherA_value) + anotherA_loc = int(anotherA_value.GetValue(), 16) + self.assertTrue(anotherA_loc == reallyA_loc) + self.assertTrue(anotherA_value.GetTypeName().find('B') == -1) + + def examine_value_object_of_this_ptr( + self, this_static, this_dynamic, dynamic_location): + # Get "this" as its static value + self.assertTrue(this_static) + this_static_loc = int(this_static.GetValue(), 16) + + # Get "this" as its dynamic value + + self.assertTrue(this_dynamic) + this_dynamic_typename = this_dynamic.GetTypeName() + self.assertTrue(this_dynamic_typename.find('B') != -1) + this_dynamic_loc = int(this_dynamic.GetValue(), 16) + + # Make sure we got the right address for "this" + + self.assertTrue(this_dynamic_loc == dynamic_location) + + # And that the static address is greater than the dynamic one + + self.assertTrue(this_static_loc > this_dynamic_loc) + + # Now read m_b_value which is only in the dynamic value: + + use_dynamic = lldb.eDynamicCanRunTarget + no_dynamic = lldb.eNoDynamicValues + + this_dynamic_m_b_value = this_dynamic.GetChildMemberWithName( + 'm_b_value', use_dynamic) + self.assertTrue(this_dynamic_m_b_value) + + m_b_value = int(this_dynamic_m_b_value.GetValue(), 0) + self.assertTrue(m_b_value == 10) + + # Make sure it is not in the static version + + this_static_m_b_value = this_static.GetChildMemberWithName( + 'm_b_value', no_dynamic) + self.assertFalse(this_static_m_b_value) + + # Okay, now let's make sure that we can get the dynamic type of a child + # element: + + contained_auto_ptr = this_dynamic.GetChildMemberWithName( + 'm_client_A', use_dynamic) + self.assertTrue(contained_auto_ptr) + contained_b = contained_auto_ptr.GetChildMemberWithName( + '_M_ptr', use_dynamic) + if not contained_b: + contained_b = contained_auto_ptr.GetChildMemberWithName( + '__ptr_', use_dynamic) + self.assertTrue(contained_b) + + contained_b_static = contained_auto_ptr.GetChildMemberWithName( + '_M_ptr', no_dynamic) + if not contained_b_static: + contained_b_static = contained_auto_ptr.GetChildMemberWithName( + '__ptr_', no_dynamic) + self.assertTrue(contained_b_static) + + contained_b_addr = int(contained_b.GetValue(), 16) + contained_b_static_addr = int(contained_b_static.GetValue(), 16) + + self.assertTrue(contained_b_addr < contained_b_static_addr) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/pass-to-base.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/pass-to-base.cpp new file mode 100644 index 00000000000..2bccf330382 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/pass-to-base.cpp @@ -0,0 +1,69 @@ +#include <stdio.h> +#include <memory> + +class Extra +{ +public: + Extra (int in_one, int in_two) : m_extra_one(in_one), m_extra_two(in_two) {} + +private: + int m_extra_one; + int m_extra_two; +}; + +class A +{ +public: + A(int value) : m_a_value (value) {} + A(int value, A* client_A) : m_a_value (value), m_client_A (client_A) {} + + virtual ~A() {} + + virtual void + doSomething (A &anotherA) + { + printf ("In A %p doing something with %d.\n", this, m_a_value); + int tmp_value = anotherA.Value(); + printf ("Also have another A at %p: %d.\n", &anotherA, tmp_value); // Break here in doSomething. + } + + int + Value() + { + return m_a_value; + } + +private: + int m_a_value; + std::auto_ptr<A> m_client_A; +}; + +class B : public Extra, public virtual A +{ +public: + B (int b_value, int a_value) : Extra(b_value, a_value), A(a_value), m_b_value(b_value) {} + B (int b_value, int a_value, A *client_A) : Extra(b_value, a_value), A(a_value, client_A), m_b_value(b_value) {} + + virtual ~B () {} + +private: + int m_b_value; +}; + +static A* my_global_A_ptr; + +int +main (int argc, char **argv) +{ + my_global_A_ptr = new B (100, 200); + B myB (10, 20, my_global_A_ptr); + B *second_fake_A_ptr = new B (150, 250); + B otherB (300, 400, second_fake_A_ptr); + + myB.doSomething(otherB); // Break here and get real addresses of myB and otherB. + + A reallyA (500); + myB.doSomething (reallyA); // Break here and get real address of reallyA. + + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/sbvalue-cast.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/sbvalue-cast.cpp new file mode 100644 index 00000000000..9e03594a734 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/sbvalue-cast.cpp @@ -0,0 +1,79 @@ +//===-- sbvalue-cast.cpp ----------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#ifdef DO_VIRTUAL_INHERITANCE +#define VIRTUAL virtual +#else +#define VIRTUAL +#endif + +#include <stdio.h> + +class Base +{ +public: + Base(int val) : m_base_val (val) {} + virtual ~Base() {} + + virtual void + forcast(int input) { + int future_val = m_base_val + input * 1; + printf("Forcasting %d\n", future_val); + } + +protected: + int m_base_val; +}; + +class DerivedA : public VIRTUAL Base +{ +public: + DerivedA(int val) : Base(val*2), m_a_val(val) { + printf("DerivedA::ctor()->\n"); + printf("m_base_val=%d\n", m_base_val); + printf("m_a_val=%d\n", m_a_val); + } + virtual ~DerivedA() {} + +private: + int m_a_val; +}; + +class DerivedB : public VIRTUAL Base +{ +public: + DerivedB(int val) : Base(val), m_b_val(val*3) { + printf("DerivedB::ctor()->\n"); + printf("m_base_val=%d\n", m_base_val); + printf("m_b_val=%d\n", m_b_val); + } + virtual ~DerivedB() {} + + virtual void + forcast(int input) { + int future_val = m_b_val + input * 2; + printf("Forcasting %d\n", future_val); + } + +private: + int m_b_val; +}; + +int +main(int argc, char **argv) +{ + DerivedA* dA = new DerivedA(10); + DerivedB* dB = new DerivedB(12); + Base *array[2] = {dA, dB}; + Base *teller = NULL; + for (int i = 0; i < 2; ++i) { + teller = array[i]; + teller->forcast(i); // Set breakpoint here. + } + + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/Makefile new file mode 100644 index 00000000000..a02c72adc20 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/Makefile @@ -0,0 +1,9 @@ +CXX_SOURCES := main.cpp + +CXXFLAGS_EXTRAS := -std=c++11 + +clean: OBJECTS+=$(wildcard main.d.*) + + + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/TestCPP11EnumTypes.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/TestCPP11EnumTypes.py new file mode 100644 index 00000000000..c58f700039e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/TestCPP11EnumTypes.py @@ -0,0 +1,156 @@ +"""Look up enum type information and check for correct display.""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class CPP11EnumTypesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_int8_t(self): + """Test C++11 enumeration class types as int8_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DSIGNED_ENUM_CLASS_TYPE=int8_t"'}) + self.image_lookup_for_enum_type(True) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_int16_t(self): + """Test C++11 enumeration class types as int16_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DSIGNED_ENUM_CLASS_TYPE=int16_t"'}) + self.image_lookup_for_enum_type(True) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_int32_t(self): + """Test C++11 enumeration class types as int32_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DSIGNED_ENUM_CLASS_TYPE=int32_t"'}) + self.image_lookup_for_enum_type(True) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_int64_t(self): + """Test C++11 enumeration class types as int64_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DSIGNED_ENUM_CLASS_TYPE=int64_t"'}) + self.image_lookup_for_enum_type(True) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_uint8_t(self): + """Test C++11 enumeration class types as uint8_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DUNSIGNED_ENUM_CLASS_TYPE=uint8_t"'}) + self.image_lookup_for_enum_type(False) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_uint16_t(self): + """Test C++11 enumeration class types as uint16_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DUNSIGNED_ENUM_CLASS_TYPE=uint16_t"'}) + self.image_lookup_for_enum_type(False) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_uint32_t(self): + """Test C++11 enumeration class types as uint32_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DUNSIGNED_ENUM_CLASS_TYPE=uint32_t"'}) + self.image_lookup_for_enum_type(False) + + @expectedFailureAll(oslist=['freebsd'], bugnumber='llvm.org/pr36527') + @skipIf(dwarf_version=['<', '4']) + def test_uint64_t(self): + """Test C++11 enumeration class types as uint64_t types.""" + self.build( + dictionary={ + 'CFLAGS_EXTRAS': '"-DUNSIGNED_ENUM_CLASS_TYPE=uint64_t"'}) + self.image_lookup_for_enum_type(False) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.line = line_number('main.cpp', '// Set break point at this line.') + + def image_lookup_for_enum_type(self, is_signed): + """Test C++11 enumeration class types.""" + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # Break inside the main. + bkpt_id = lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("run", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) + + # Look up information about the 'DayType' enum type. + # Check for correct display. + self.expect("image lookup -t DayType", DATA_TYPES_DISPLAYED_CORRECTLY, + patterns=['enum( struct| class) DayType {'], + substrs=['Monday', + 'Tuesday', + 'Wednesday', + 'Thursday', + 'Friday', + 'Saturday', + 'Sunday', + 'kNumDays', + '}']) + + if is_signed: + enum_values = ['-4', + 'Monday', + 'Tuesday', + 'Wednesday', + 'Thursday', + 'Friday', + 'Saturday', + 'Sunday', + 'kNumDays', + '5'] + else: + enum_values = ['199', + 'Monday', + 'Tuesday', + 'Wednesday', + 'Thursday', + 'Friday', + 'Saturday', + 'Sunday', + 'kNumDays', + '208'] + + bkpt = self.target().FindBreakpointByID(bkpt_id) + for enum_value in enum_values: + self.expect( + "frame variable day", + 'check for valid enumeration value', + substrs=[enum_value]) + lldbutil.continue_to_breakpoint(self.process(), bkpt) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/main.cpp new file mode 100644 index 00000000000..e00fc2df460 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/enum_types/main.cpp @@ -0,0 +1,48 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include <stdio.h> +#include <stdint.h> + + +int main (int argc, char const *argv[]) +{ +#ifdef SIGNED_ENUM_CLASS_TYPE + typedef SIGNED_ENUM_CLASS_TYPE enum_integer_t; + enum class DayType : enum_integer_t { + Monday = -3, + Tuesday, + Wednesday, + Thursday, + Friday, + Saturday, + Sunday, + kNumDays + }; + enum_integer_t day_value; +#else + typedef UNSIGNED_ENUM_CLASS_TYPE enum_integer_t; + enum class DayType : enum_integer_t { + Monday = 200, + Tuesday, + Wednesday, + Thursday, + Friday, + Saturday, + Sunday, + kNumDays + }; + enum_integer_t day_value; +#endif + + for (day_value = (enum_integer_t)DayType::Monday - 1; day_value <= (enum_integer_t)DayType::kNumDays + 1; ++day_value) + { + DayType day = (DayType)day_value; + printf("day as int is %i\n", (int)day); // Set break point at this line. + } + return 0; // Break here for char tests +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/Makefile new file mode 100644 index 00000000000..edb53da7b8e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := exceptions.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py new file mode 100644 index 00000000000..e888958987a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py @@ -0,0 +1,82 @@ +""" +Test lldb exception breakpoint command for CPP. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CPPBreakpointTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + self.source = 'exceptions.cpp' + self.catch_line = line_number( + self.source, '// This is the line you should stop at for catch') + + @expectedFailureAll( + oslist=["windows"], + bugnumber="llvm.org/pr24538, clang-cl does not support throw or catch") + @expectedFailureNetBSD + def test(self): + """Test lldb exception breakpoint command for CPP.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target from the debugger. + + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + exception_bkpt = target.BreakpointCreateForException( + lldb.eLanguageTypeC_plus_plus, True, True) + self.assertTrue(exception_bkpt, "Made an exception breakpoint") + + # Now run, and make sure we hit our breakpoint: + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process, "Got a valid process") + + stopped_threads = [] + stopped_threads = lldbutil.get_threads_stopped_at_breakpoint( + process, exception_bkpt) + self.assertTrue( + len(stopped_threads) == 1, + "Stopped at our exception breakpoint.") + thread = stopped_threads[0] + # Make sure our throw function is still above us on the stack: + + frame_functions = lldbutil.get_function_names(thread) + self.assertTrue( + frame_functions.count("throws_exception_on_even(int)") == 1, + "Our throw function is still on the stack.") + + # Okay we hit our exception throw breakpoint, now make sure we get our catch breakpoint. + # One potential complication is that we might hit a couple of the exception breakpoints in getting out of the throw. + # so loop till we don't see the throws function on the stack. We should stop one more time for our exception breakpoint + # and that should be the catch... + + while frame_functions.count("throws_exception_on_even(int)") == 1: + stopped_threads = lldbutil.continue_to_breakpoint( + process, exception_bkpt) + self.assertTrue(len(stopped_threads) == 1) + + thread = stopped_threads[0] + frame_functions = lldbutil.get_function_names(thread) + + self.assertTrue( + frame_functions.count("throws_exception_on_even(int)") == 0, + "At catch our throw function is off the stack") + self.assertTrue( + frame_functions.count("intervening_function(int)") == 0, + "At catch our intervening function is off the stack") + self.assertTrue( + frame_functions.count("catches_exception(int)") == 1, + "At catch our catch function is on the stack") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/exceptions.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/exceptions.cpp new file mode 100644 index 00000000000..150d420b241 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/exceptions/exceptions.cpp @@ -0,0 +1,42 @@ +#include <exception> +#include <stdio.h> + +int throws_exception_on_even (int value); +int intervening_function (int value); +int catches_exception (int value); + +int +catches_exception (int value) +{ + try + { + return intervening_function(value); // This is the line you should stop at for catch + } + catch (int value) + { + return value; + } +} + +int +intervening_function (int value) +{ + return throws_exception_on_even (2 * value); +} + +int +throws_exception_on_even (int value) +{ + printf ("Mod two works: %d.\n", value%2); + if (value % 2 == 0) + throw 30; + else + return value; +} + +int +main () +{ + catches_exception (10); // Stop here + return 5; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/extern_c/TestExternCSymbols.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/extern_c/TestExternCSymbols.py new file mode 100644 index 00000000000..b1b7e1744f1 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/extern_c/TestExternCSymbols.py @@ -0,0 +1,4 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals(), lldbinline.expectedFailureAll(oslist=["windows"])) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/extern_c/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/extern_c/main.cpp new file mode 100644 index 00000000000..47769014d49 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/extern_c/main.cpp @@ -0,0 +1,28 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> +#include <stdint.h> + +extern "C" +{ + int foo(); +}; + +int foo() +{ + puts("foo"); + return 2; +} + +int main (int argc, char const *argv[], char const *envp[]) +{ + foo(); + return 0; //% self.expect("expression -- foo()", substrs = ['2']) +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/TestFrameVariableAnonymousUnions.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/TestFrameVariableAnonymousUnions.py new file mode 100644 index 00000000000..6352b68e7d7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/TestFrameVariableAnonymousUnions.py @@ -0,0 +1,35 @@ +""" +Tests that frame variable looks into anonymous unions +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class FrameVariableAnonymousUnionsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_with_run_command(self): + """Tests that frame variable looks into anonymous unions""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + line = line_number('main.cpp', '// break here') + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=-1, loc_exact=False) + + self.runCmd("process launch", RUN_SUCCEEDED) + + process = self.dbg.GetSelectedTarget().GetProcess() + + if process.GetByteOrder() == lldb.eByteOrderLittle: + self.expect('frame variable -f x i', substrs=['ffffff41']) + else: + self.expect('frame variable -f x i', substrs=['41ffff00']) + + self.expect('frame variable c', substrs=["'A"]) + + self.expect('frame variable x', matching=False, substrs=['3']) + self.expect('frame variable y', matching=False, substrs=["'B'"]) + self.expect('frame variable z', matching=False, substrs=['14']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/main.cpp new file mode 100644 index 00000000000..2489506b280 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/main.cpp @@ -0,0 +1,22 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +int main() { + union { + int i; + char c; + }; + struct { + int x; + char y; + short z; + } s{3,'B',14}; + i = 0xFFFFFF00; + c = 'A'; + return c; // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function-template-parameter-pack/TestFunctionTemplateParameterPack.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function-template-parameter-pack/TestFunctionTemplateParameterPack.py new file mode 100644 index 00000000000..b90f74656cd --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function-template-parameter-pack/TestFunctionTemplateParameterPack.py @@ -0,0 +1,12 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +# https://bugs.llvm.org/show_bug.cgi?id=35920 +# This test stresses expression evaluation support for template functions. +# Currently the support is rudimentary, and running this test causes assertion +# failures in clang. This test cannot be XFAIL'ed because the test harness +# treats assertion failures as unexpected events. For now, the test must be +# skipped. +lldbinline.MakeInlineTest( + __file__, globals(), [ + decorators.skipIf]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function-template-parameter-pack/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function-template-parameter-pack/main.cpp new file mode 100644 index 00000000000..eea2830aef8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function-template-parameter-pack/main.cpp @@ -0,0 +1,23 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +template <class T> int staticSizeof() { + return sizeof(T); +} + +template <class T1, class T2, class... Ts> int staticSizeof() { + return staticSizeof<T2, Ts...>() + sizeof(T1); +} + +int main (int argc, char const *argv[]) +{ + int sz = staticSizeof<long, int, char>(); + return staticSizeof<long, int, char>() != sz; //% self.expect("expression -- sz == staticSizeof<long, int, char>()", "staticSizeof<long, int, char> worked", substrs = ["true"]) + //% self.expect("expression -- sz == staticSizeof<long, int>() + sizeof(char)", "staticSizeof<long, int> worked", substrs = ["true"]) + //% self.expect("expression -- sz == staticSizeof<long>() + sizeof(int) + sizeof(char)", "staticSizeof<long> worked", substrs = ["true"]) +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function_refs/TestFunctionRefs.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function_refs/TestFunctionRefs.py new file mode 100644 index 00000000000..293e9139637 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function_refs/TestFunctionRefs.py @@ -0,0 +1,5 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals(), + lldbinline.expectedFailureAll(oslist=["windows"])) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function_refs/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function_refs/main.cpp new file mode 100644 index 00000000000..a57b0867fb8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/function_refs/main.cpp @@ -0,0 +1,32 @@ +// This is plagiarized from lit/SymbolFile/NativePDB/function-types-builtin.cpp. +void nullary() {} + +template<typename Arg> +void unary(Arg) { } + +template<typename A1, typename A2> +void binary(A1, A2) { } + +int varargs(int, int, ...) { return 0; } + +auto &ref = unary<bool>; +auto &ref2 = unary<volatile int*>; +auto &ref3 = varargs; +auto binp = &binary<int*, const int*>; +auto &binr = binary<int*, const int*>; +auto null = &nullary; +int main(int argc, char **argv) { +//% self.expect("target var ref", substrs=["(void (&)(bool))", "ref = 0x", +//% "&::ref = <no summary available>"]) +//% self.expect("target var ref2", +//% substrs=["(void (&)(volatile int *))", "ref2 = 0x"]) +//% self.expect("target var ref3", +//% substrs=["(int (&)(int, int, ...))", "ref3 = 0x"]) +//% self.expect("target var binp", +//% substrs=["(void (*)(int *, const int *))", "binp = 0x"]) +//% self.expect("target var binr", +//% substrs=["(void (&)(int *, const int *))", "binr = 0x"]) +//% self.expect("target var null", +//% substrs=["(void (*)())", "null = 0x"]) + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py new file mode 100644 index 00000000000..4ead709cf56 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py @@ -0,0 +1,93 @@ +""" +Test that global operators are found and evaluated. +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestCppGlobalOperators(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def prepare_executable_and_get_frame(self): + self.build() + + # Get main source file + src_file = "main.cpp" + src_file_spec = lldb.SBFileSpec(src_file) + self.assertTrue(src_file_spec.IsValid(), "Main source file") + + # Get the path of the executable + exe_path = self.getBuildArtifact("a.out") + + # Load the executable + target = self.dbg.CreateTarget(exe_path) + self.assertTrue(target.IsValid(), VALID_TARGET) + + # Break on main function + main_breakpoint = target.BreakpointCreateBySourceRegex( + "// break here", src_file_spec) + self.assertTrue( + main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + args = None + env = None + process = target.LaunchSimple( + args, env, self.get_process_working_directory()) + self.assertTrue(process.IsValid(), PROCESS_IS_VALID) + + # Get the thread of the process + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + + return thread.GetSelectedFrame() + + def test_equals_operator(self): + frame = self.prepare_executable_and_get_frame() + + test_result = frame.EvaluateExpression("operator==(s1, s2)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "operator==(s1, s2) = false") + + test_result = frame.EvaluateExpression("operator==(s1, s3)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "true", + "operator==(s1, s3) = true") + + test_result = frame.EvaluateExpression("operator==(s2, s3)") + self.assertTrue( + test_result.IsValid() and test_result.GetValue() == "false", + "operator==(s2, s3) = false") + + def do_new_test(self, frame, expr, expected_value_name): + """Evaluate a new expression, and check its result""" + + expected_value = frame.FindValue( + expected_value_name, lldb.eValueTypeVariableGlobal) + self.assertTrue(expected_value.IsValid()) + + expected_value_addr = expected_value.AddressOf() + self.assertTrue(expected_value_addr.IsValid()) + + got = frame.EvaluateExpression(expr) + self.assertTrue(got.IsValid()) + self.assertEqual( + got.GetValueAsUnsigned(), + expected_value_addr.GetValueAsUnsigned()) + got_type = got.GetType() + self.assertTrue(got_type.IsPointerType()) + self.assertEqual(got_type.GetPointeeType().GetName(), "Struct") + + def test_operator_new(self): + frame = self.prepare_executable_and_get_frame() + + self.do_new_test(frame, "new Struct()", "global_new_buf") + self.do_new_test(frame, "new(new_tag) Struct()", "tagged_new_buf") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/main.cpp new file mode 100644 index 00000000000..c6dafd29586 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_operators/main.cpp @@ -0,0 +1,42 @@ +#include <new> + +struct new_tag_t +{ +}; +new_tag_t new_tag; + +struct Struct { + int value; +}; + +bool operator==(const Struct &a, const Struct &b) { + return a.value == b.value; +} + +typedef char buf_t[sizeof(Struct)]; +buf_t global_new_buf, tagged_new_buf; + +// This overrides global operator new +// This function and the following does not actually allocate memory. We are merely +// trying to make sure it is getting called. +void * +operator new(std::size_t count) +{ + return &global_new_buf; +} + +// A custom allocator +void * +operator new(std::size_t count, const new_tag_t &) +{ + return &tagged_new_buf; +} + +int main() { + Struct s1, s2, s3; + s1.value = 3; + s2.value = 5; + s3.value = 3; + return 0; // break here +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/TestCPPGlobalVariables.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/TestCPPGlobalVariables.py new file mode 100644 index 00000000000..4870247995f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/TestCPPGlobalVariables.py @@ -0,0 +1,40 @@ +"""Test that C++ global variables can be inspected by name and also their mangled name.""" + + + +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class GlobalVariablesCppTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + TestBase.setUp(self) + self.source = lldb.SBFileSpec('main.cpp') + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") + def test(self): + self.build() + + (target, _, _, _) = lldbutil.run_to_source_breakpoint(self, "// Set break point at this line.", self.source) + + # Check that we can access g_file_global_int by its name + self.expect("target variable g_file_global_int", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['42']) + self.expect("target variable abc::g_file_global_int", VARIABLES_DISPLAYED_CORRECTLY, + substrs=['42']) + self.expect("target variable xyz::g_file_global_int", VARIABLES_DISPLAYED_CORRECTLY, + error=True, substrs=['can\'t find global variable']) + + # Check that we can access g_file_global_int by its mangled name + addr = target.EvaluateExpression("&abc::g_file_global_int").GetValueAsUnsigned() + self.assertTrue(addr != 0) + mangled = lldb.SBAddress(addr, target).GetSymbol().GetMangledName() + self.assertTrue(mangled != None) + gv = target.FindFirstGlobalVariable(mangled) + self.assertTrue(gv.IsValid()) + self.assertEqual(gv.GetName(), "abc::g_file_global_int") + self.assertEqual(gv.GetValueAsUnsigned(), 42) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/main.cpp new file mode 100644 index 00000000000..0a164186e71 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/global_variables/main.cpp @@ -0,0 +1,17 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include <stdio.h> + +namespace abc { + int g_file_global_int = 42; +} + +int main (int argc, char const *argv[]) +{ + return abc::g_file_global_int; // Set break point at this line. +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/TestGModules.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/TestGModules.py new file mode 100644 index 00000000000..69d04636d86 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/TestGModules.py @@ -0,0 +1,6 @@ +import lldbsuite.test.lldbinline as lldbinline +from lldbsuite.test.decorators import * + +lldbinline.MakeInlineTest(__file__, globals(), [ + expectedFailureAll(oslist=["linux"], bugnumber="llvm.org/pr36107", + debug_info="gmodules")]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/a.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/a.h new file mode 100644 index 00000000000..7384f230801 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/a.h @@ -0,0 +1,7 @@ +#include "memory.h" + +class MemoryBuffer { int buffer = 42; }; + +struct SrcBuffer { + my_std::unique_ptr<MemoryBuffer> Buffer; +}; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/b.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/b.h new file mode 100644 index 00000000000..b777e8e3473 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/b.h @@ -0,0 +1,6 @@ +#include "a.h" +#include "memory.h" + +class Module { + my_std::unique_ptr<MemoryBuffer> MBptr; +}; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/main.cpp new file mode 100644 index 00000000000..df752616570 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/main.cpp @@ -0,0 +1,9 @@ +#include "b.h" + +int main(int argc, const char * argv[]) +{ + Module m; + // Test that the type Module which contains a field that is a + // template instantiation can be fully resolved. + return 0; //% self.assertTrue(self.frame().FindVariable('m').GetChildAtIndex(0).GetChildAtIndex(0).GetChildAtIndex(0).GetName() == 'buffer', 'find template specializations in imported modules') +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/memory.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/memory.h new file mode 100644 index 00000000000..1d59dc0bbf0 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/memory.h @@ -0,0 +1,8 @@ +#ifndef MEMORY_H +#define MEMORY_H +namespace my_std { + template<class T> class unique_ptr { + T t; + }; +} +#endif diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/module.modulemap b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/module.modulemap new file mode 100644 index 00000000000..2f05073a0b8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules-templates/module.modulemap @@ -0,0 +1,11 @@ +module A { + header "a.h" +} + +module B { + header "b.h" +} + +module std { + header "memory.h" +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/Makefile new file mode 100644 index 00000000000..a98dca64e8a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/Makefile @@ -0,0 +1,5 @@ +PCH_CXX_SOURCE = pch.h +CXX_SOURCES = main.cpp +CFLAGS_EXTRAS := $(MODULE_DEBUG_INFO_FLAGS) + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/TestWithModuleDebugging.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/TestWithModuleDebugging.py new file mode 100644 index 00000000000..20207c54db9 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/TestWithModuleDebugging.py @@ -0,0 +1,94 @@ +import lldb +import os +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestWithGmodulesDebugInfo(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipIf(bugnumber="llvm.org/pr36146", oslist=["linux"], archs=["i386"]) + @add_test_categories(["gmodules"]) + def test_specialized_typedef_from_pch(self): + self.build() + + src_file = os.path.join(self.getSourceDir(), "main.cpp") + src_file_spec = lldb.SBFileSpec(src_file) + self.assertTrue(src_file_spec.IsValid(), "breakpoint file") + + # Get the path of the executable + exe_path = self.getBuildArtifact("a.out") + + # Load the executable + target = self.dbg.CreateTarget(exe_path) + self.assertTrue(target.IsValid(), VALID_TARGET) + + # Break on interesting line + breakpoint = target.BreakpointCreateBySourceRegex( + "break here", src_file_spec) + self.assertTrue( + breakpoint.IsValid() and breakpoint.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process.IsValid(), PROCESS_IS_VALID) + + # Get the thread of the process + self.assertTrue(process.GetState() == lldb.eStateStopped) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertTrue( + thread.IsValid(), + "There should be a thread stopped due to breakpoint condition") + + # Get frame for current thread + frame = thread.frames[0] + + testValue = frame.EvaluateExpression("test") + self.assertTrue( + testValue.GetError().Success(), + "Test expression value invalid: %s" % + (testValue.GetError().GetCString())) + self.assertTrue( + testValue.GetTypeName() == "IntContainer", + "Test expression type incorrect") + + memberValue = testValue.GetChildMemberWithName("storage") + self.assertTrue( + memberValue.GetError().Success(), + "Member value missing or invalid: %s" % + (testValue.GetError().GetCString())) + self.assertTrue( + memberValue.GetTypeName() == "int", + "Member type incorrect") + self.assertEqual( + 42, + memberValue.GetValueAsSigned(), + "Member value incorrect") + + testValue = frame.EvaluateExpression("bar") + self.assertTrue( + testValue.GetError().Success(), + "Test expression value invalid: %s" % + (testValue.GetError().GetCString())) + self.assertTrue( + testValue.GetTypeName() == "Foo::Bar", + "Test expression type incorrect") + + memberValue = testValue.GetChildMemberWithName("i") + self.assertTrue( + memberValue.GetError().Success(), + "Member value missing or invalid: %s" % + (testValue.GetError().GetCString())) + self.assertTrue( + memberValue.GetTypeName() == "int", + "Member type incorrect") + self.assertEqual( + 123, + memberValue.GetValueAsSigned(), + "Member value incorrect") + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/main.cpp new file mode 100644 index 00000000000..588a3a8e01f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/main.cpp @@ -0,0 +1,8 @@ +class Foo::Bar { int i = 123; }; + +int main(int argc, const char * argv[]) +{ + IntContainer test(42); + Foo::Bar bar; + return 0; // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/pch.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/pch.h new file mode 100644 index 00000000000..dba4fee9a8c --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/gmodules/pch.h @@ -0,0 +1,17 @@ +template<typename T> +class GenericContainer { + private: + T storage; + + public: + GenericContainer(T value) { + storage = value; + }; +}; + +typedef GenericContainer<int> IntContainer; + +struct Foo { + class Bar; + Bar *bar; +}; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/Makefile new file mode 100644 index 00000000000..769920c2833 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/Makefile @@ -0,0 +1,33 @@ +CXX_SOURCES = main.cpp length.cpp a.cpp + +CFLAGS_LIMIT = -c $(CXXFLAGS) +CFLAGS_NO_LIMIT = -c $(CXXFLAGS) + +ifneq (,$(findstring clang,$(CC))) + CFLAGS_LIMIT += -flimit-debug-info + CFLAGS_NO_LIMIT += -fno-limit-debug-info +endif + +all: limit nolimit + +limit: main.o length_limit.o a.o + $(CXX) main.o length_limit.o a.o -o limit $(LDFLAGS) + +nolimit: main.o length_nolimit.o a.o + $(CXX) main.o length_nolimit.o a.o -o nolimit $(LDFLAGS) + +main.o: main.cpp + $(CXX) $(CFLAGS_LIMIT) $(SRCDIR)/main.cpp -o main.o + +length_limit.o: length.cpp + $(CXX) $(CFLAGS_LIMIT) $(SRCDIR)/length.cpp -o length_limit.o + +length_nolimit.o: length.cpp + $(CXX) $(CFLAGS_NO_LIMIT) $(SRCDIR)/length.cpp -o length_nolimit.o + +a.o: a.cpp + $(CXX) $(CFLAGS_NO_DEBUG) -c $(SRCDIR)/a.cpp -o a.o + +clean: OBJECTS += limit nolimit length_limit.o length_nolimit.o length_limit.dwo length_nolimit.dwo + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py new file mode 100644 index 00000000000..7ce2e343b88 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py @@ -0,0 +1,55 @@ +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestCppIncompleteTypes(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipIf(compiler="gcc") + def test_limit_debug_info(self): + self.build() + frame = self.get_test_frame('limit') + + value_f = frame.EvaluateExpression("f") + self.assertTrue( + value_f.IsValid(), + "'expr f' results in a valid SBValue object") + self.assertTrue(value_f.GetError().Success(), "'expr f' is successful") + + value_a = frame.EvaluateExpression("a") + self.assertTrue( + value_a.IsValid(), + "'expr a' results in a valid SBValue object") + self.assertTrue(value_a.GetError().Success(), "'expr a' is successful") + + @skipIf(compiler="gcc") + # Clang on Windows asserts in external record layout in this case. + @skipIfWindows + def test_partial_limit_debug_info(self): + self.build() + frame = self.get_test_frame('nolimit') + + value_f = frame.EvaluateExpression("f") + self.assertTrue( + value_f.IsValid(), + "'expr f' results in a valid SBValue object") + self.assertTrue(value_f.GetError().Success(), "'expr f' is successful") + + value_a = frame.EvaluateExpression("a") + self.assertTrue( + value_a.IsValid(), + "'expr a' results in a valid SBValue object") + self.assertTrue(value_a.GetError().Success(), "'expr a' is successful") + + def get_test_frame(self, exe): + # Get main source file + src_file = "main.cpp" + src_file_spec = lldb.SBFileSpec(src_file) + + (target, process, thread, main_breakpoint) = lldbutil.run_to_source_breakpoint(self, + "break here", src_file_spec, exe_name = exe) + # Get frame for current thread + return thread.GetSelectedFrame() diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.cpp new file mode 100644 index 00000000000..36b374be6f3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.cpp @@ -0,0 +1,10 @@ + +#include "a.h" + +A::A () { } + +int +A::length () +{ + return 123; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.h new file mode 100644 index 00000000000..13e9496e3fd --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.h @@ -0,0 +1,11 @@ +#ifndef __A_H__ +#define __A_H__ + +class A +{ +public: + A(); + virtual int length(); +}; + +#endif diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.cpp new file mode 100644 index 00000000000..90a3b640f73 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.cpp @@ -0,0 +1,8 @@ + +#include "length.h" + +int +length (A &a) +{ + return a.length(); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.h new file mode 100644 index 00000000000..96df4f02180 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.h @@ -0,0 +1,8 @@ +#ifndef __LENGTH_H__ +#define __LENGTH_H__ + +#include "a.h" + +int length (A &a); + +#endif diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/main.cpp new file mode 100644 index 00000000000..ad324c90581 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/main.cpp @@ -0,0 +1,18 @@ + +#include "length.h" + +class Foo { +public: + A a; +}; + +class MyA : public A { +}; + +int main() +{ + Foo f; + MyA a; + + return length(a); // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/Makefile new file mode 100644 index 00000000000..055e318e220 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := inlines.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/TestInlines.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/TestInlines.py new file mode 100644 index 00000000000..5f77d8f5963 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/TestInlines.py @@ -0,0 +1,59 @@ +"""Test variable lookup when stopped in inline functions.""" + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class InlinesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.line = line_number( + 'inlines.cpp', + '// Set break point at this line.') + + @expectedFailureAll("llvm.org/pr26710", oslist=["linux"], compiler="gcc") + def test(self): + """Test that local variables are visible in expressions.""" + self.build() + self.runToBreakpoint() + + # Check that 'frame variable' finds a variable + self.expect( + "frame variable inner_input", + VARIABLES_DISPLAYED_CORRECTLY, + startstr='(int) inner_input =') + + # Check that 'expr' finds a variable + self.expect("expr inner_input", VARIABLES_DISPLAYED_CORRECTLY, + startstr='(int) $0 =') + + def runToBreakpoint(self): + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # Break inside the main. + lldbutil.run_break_set_by_file_and_line( + self, + "inlines.cpp", + self.line, + num_expected_locations=2, + loc_exact=True) + + self.runCmd("run", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/inlines.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/inlines.cpp new file mode 100644 index 00000000000..822d88e22f9 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/inlines.cpp @@ -0,0 +1,53 @@ +#include <stdio.h> +#include "inlines.h" + +#define INLINE_ME __inline__ __attribute__((always_inline)) + +int +not_inlined_2 (int input) +{ + printf ("Called in not_inlined_2 with : %d.\n", input); + return input; +} + +int +not_inlined_1 (int input) +{ + printf ("Called in not_inlined_1 with %d.\n", input); + return not_inlined_2(input); +} + +INLINE_ME int +inner_inline (int inner_input, int mod_value) +{ + int inner_result; + inner_result = inner_input % mod_value; + printf ("Returning: %d.\n", inner_result); + return not_inlined_1 (inner_result); // Set break point at this line. +} + +INLINE_ME int +outer_inline (int outer_input) +{ + int outer_result; + + outer_result = inner_inline (outer_input, outer_input % 3); + return outer_result; +} + +int +main (int argc, char **argv) +{ + printf ("Starting...\n"); + + int (*func_ptr) (int); + func_ptr = outer_inline; + + outer_inline (argc); + + func_ptr (argc); + + return 0; +} + + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/inlines.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/inlines.h new file mode 100644 index 00000000000..265d7b4966e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/inlines/inlines.h @@ -0,0 +1,4 @@ +int inner_inline (int inner_input, int mod_value); +int outer_inline (int outer_input); +int not_inlined_2 (int input); +int not_inlined_1 (int input); diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/lambdas/TestLambdas.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/lambdas/TestLambdas.py new file mode 100644 index 00000000000..c8308c16011 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/lambdas/TestLambdas.py @@ -0,0 +1,4 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals()) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/lambdas/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/lambdas/main.cpp new file mode 100644 index 00000000000..5870c877f4a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/lambdas/main.cpp @@ -0,0 +1,16 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +int main (int argc, char const *argv[]) +{ + printf("Stop here\n"); //% self.runCmd("expression auto $add = [](int first, int second) { return first + second; }") + //% self.expect("expression $add(2,3)", substrs = ['= 5']) + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/Makefile new file mode 100644 index 00000000000..ba7e0153752 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/Makefile @@ -0,0 +1,5 @@ +CXX_SOURCES = main.cpp derived.cpp base.cpp + +CFLAGS_EXTRAS := $(LIMIT_DEBUG_INFO_FLAGS) + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py new file mode 100644 index 00000000000..ae50d3d3966 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py @@ -0,0 +1,63 @@ +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestWithLimitDebugInfo(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipIf(debug_info=no_match(["dwarf"])) + def test_limit_debug_info(self): + self.build() + + src_file = os.path.join(self.getSourceDir(), "main.cpp") + src_file_spec = lldb.SBFileSpec(src_file) + self.assertTrue(src_file_spec.IsValid(), "breakpoint file") + + # Get the path of the executable + exe_path = self.getBuildArtifact("a.out") + + # Load the executable + target = self.dbg.CreateTarget(exe_path) + self.assertTrue(target.IsValid(), VALID_TARGET) + + # Break on main function + breakpoint = target.BreakpointCreateBySourceRegex( + "break here", src_file_spec) + self.assertTrue( + breakpoint.IsValid() and breakpoint.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process.IsValid(), PROCESS_IS_VALID) + + # Get the thread of the process + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + thread.StepInto() + + # Get frame for current thread + frame = thread.GetSelectedFrame() + + v1 = frame.EvaluateExpression("1") + self.assertTrue( + v1.IsValid(), + "'expr 1' results in a valid SBValue object") + self.assertTrue( + v1.GetError().Success(), + "'expr 1' succeeds without an error.") + + v2 = frame.EvaluateExpression("this") + self.assertTrue( + v2.IsValid(), + "'expr this' results in a valid SBValue object") + self.assertTrue( + v2.GetError().Success(), + "'expr this' succeeds without an error.") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.cpp new file mode 100644 index 00000000000..4023bdbc64a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.cpp @@ -0,0 +1,6 @@ +#include "base.h" + +void FooNS::bar() { + x = 54321; +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.h new file mode 100644 index 00000000000..d3a09572bd2 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.h @@ -0,0 +1,10 @@ +class FooNS +{ +public: + virtual void bar(); + virtual char baz() = 0; + +protected: + int x; +}; + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.cpp new file mode 100644 index 00000000000..9d773593eb5 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.cpp @@ -0,0 +1,6 @@ +#include "derived.h" + +char Foo::baz() { + return (char)(x&0xff); +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.h new file mode 100644 index 00000000000..46b3f83b9f7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.h @@ -0,0 +1,13 @@ +#include "base.h" + +class Foo : public FooNS +{ +public: + Foo() { + a = 12345; + } + + char baz() override; + int a; +}; + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/main.cpp new file mode 100644 index 00000000000..64e0349b582 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/main.cpp @@ -0,0 +1,7 @@ +#include "derived.h" + +int main() { + Foo f; // break here + f.bar(); + return f.baz(); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/llvm-style/TestLLVMStyle.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/llvm-style/TestLLVMStyle.py new file mode 100644 index 00000000000..c8308c16011 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/llvm-style/TestLLVMStyle.py @@ -0,0 +1,4 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals()) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/llvm-style/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/llvm-style/main.cpp new file mode 100644 index 00000000000..048eeb2d27b --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/llvm-style/main.cpp @@ -0,0 +1,35 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +namespace n { + struct D { + int i; + static int anInt() { return 2; } + int dump() { return i; } + }; + + class C { + public: + int foo(D *D); + }; +} + +using namespace n; + +int C::foo(D* D) { + return D->dump(); //% self.expect("expression -- D->dump()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["int", "2"]) + //% self.expect("expression -- D::anInt()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["int", "2"]) + +} + +int main (int argc, char const *argv[]) +{ + D myD { D::anInt() }; + C().foo(&myD); + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/Makefile new file mode 100644 index 00000000000..82f96b62609 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES = main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/TestMembersAndLocalsWithSameName.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/TestMembersAndLocalsWithSameName.py new file mode 100644 index 00000000000..a0dcbf00266 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/TestMembersAndLocalsWithSameName.py @@ -0,0 +1,285 @@ +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class TestMembersAndLocalsWithSameName(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_when_stopped_in_method(self): + self._load_exe() + + # Set breakpoints + bp1 = self.target.BreakpointCreateBySourceRegex( + "Break 1", self.src_file_spec) + self.assertTrue( + bp1.IsValid() and bp1.GetNumLocations() >= 1, + VALID_BREAKPOINT) + bp2 = self.target.BreakpointCreateBySourceRegex( + "Break 2", self.src_file_spec) + self.assertTrue( + bp2.IsValid() and bp2.GetNumLocations() >= 1, + VALID_BREAKPOINT) + bp3 = self.target.BreakpointCreateBySourceRegex( + "Break 3", self.src_file_spec) + self.assertTrue( + bp3.IsValid() and bp3.GetNumLocations() >= 1, + VALID_BREAKPOINT) + bp4 = self.target.BreakpointCreateBySourceRegex( + "Break 4", self.src_file_spec) + self.assertTrue( + bp4.IsValid() and bp4.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + self.process = self.target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID) + + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + self._test_globals() + + self.process.Continue() + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + self.process, lldb.eStopReasonBreakpoint) + self.assertTrue(thread.IsValid()) + frame = thread.GetSelectedFrame() + self.assertTrue(frame.IsValid()) + + val = frame.EvaluateExpression("a") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 12345) + + val = frame.EvaluateExpression("b") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 54321) + + val = frame.EvaluateExpression("c") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 34567) + + self.process.Continue() + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + self.process, lldb.eStopReasonBreakpoint) + self.assertTrue(thread.IsValid()) + frame = thread.GetSelectedFrame() + self.assertTrue(frame.IsValid()) + + val = frame.EvaluateExpression("a") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 10001) + + val = frame.EvaluateExpression("b") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 10002) + + val = frame.EvaluateExpression("c") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 10003) + + self.process.Continue() + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + self.process, lldb.eStopReasonBreakpoint) + self.assertTrue(thread.IsValid()) + frame = thread.GetSelectedFrame() + self.assertTrue(frame.IsValid()) + + val = frame.EvaluateExpression("a") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 1) + + val = frame.EvaluateExpression("b") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 2) + + val = frame.EvaluateExpression("c") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 778899) + + def test_when_stopped_in_function(self): + self._load_exe() + + # Set breakpoints + bp1 = self.target.BreakpointCreateBySourceRegex( + "Break 1", self.src_file_spec) + self.assertTrue( + bp1.IsValid() and bp1.GetNumLocations() >= 1, + VALID_BREAKPOINT) + bp5 = self.target.BreakpointCreateBySourceRegex( + "Break 5", self.src_file_spec) + self.assertTrue( + bp5.IsValid() and bp5.GetNumLocations() >= 1, + VALID_BREAKPOINT) + bp6 = self.target.BreakpointCreateBySourceRegex( + "Break 6", self.src_file_spec) + self.assertTrue( + bp6.IsValid() and bp6.GetNumLocations() >= 1, + VALID_BREAKPOINT) + bp7 = self.target.BreakpointCreateBySourceRegex( + "Break 7", self.src_file_spec) + self.assertTrue( + bp7.IsValid() and bp7.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + self.process = self.target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(self.process.IsValid(), PROCESS_IS_VALID) + + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + + self._test_globals() + + self.process.Continue() + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + self.process, lldb.eStopReasonBreakpoint) + self.assertTrue(thread.IsValid()) + frame = thread.GetSelectedFrame() + self.assertTrue(frame.IsValid()) + + self.enable_expression_log() + val = frame.EvaluateExpression("a") + self.disable_expression_log_and_check_for_locals(['a']) + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 12345) + + val = frame.EvaluateExpression("b") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 54321) + + val = frame.EvaluateExpression("c") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 34567) + + self.process.Continue() + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + self.process, lldb.eStopReasonBreakpoint) + self.assertTrue(thread.IsValid()) + frame = thread.GetSelectedFrame() + self.assertTrue(frame.IsValid()) + + val = frame.EvaluateExpression("a") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 10001) + + val = frame.EvaluateExpression("b") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 10002) + + val = frame.EvaluateExpression("c") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 10003) + + self.enable_expression_log() + val = frame.EvaluateExpression("c-b") + self.disable_expression_log_and_check_for_locals(['c','b']) + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 1) + + self.process.Continue() + self.assertTrue( + self.process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + self.process, lldb.eStopReasonBreakpoint) + self.assertTrue(thread.IsValid()) + frame = thread.GetSelectedFrame() + self.assertTrue(frame.IsValid()) + + val = frame.EvaluateExpression("a") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 1) + + val = frame.EvaluateExpression("b") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 2) + + val = frame.EvaluateExpression("c") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 778899) + + self.enable_expression_log() + val = frame.EvaluateExpression("a+b") + self.disable_expression_log_and_check_for_locals(['a','b']) + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 3) + + + def _load_exe(self): + self.build() + + cwd = os.getcwd() + + src_file = os.path.join(cwd, "main.cpp") + self.src_file_spec = lldb.SBFileSpec(src_file) + self.assertTrue(self.src_file_spec.IsValid(), "breakpoint file") + + # Get the path of the executable + exe_path = self.getBuildArtifact("a.out") + + # Load the executable + self.target = self.dbg.CreateTarget(exe_path) + self.assertTrue(self.target.IsValid(), VALID_TARGET) + + def _test_globals(self): + thread = lldbutil.get_stopped_thread( + self.process, lldb.eStopReasonBreakpoint) + self.assertTrue(thread.IsValid()) + frame = thread.GetSelectedFrame() + self.assertTrue(frame.IsValid()) + + self.enable_expression_log() + val = frame.EvaluateExpression("a") + self.disable_expression_log_and_check_for_locals([]) + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 112233) + + val = frame.EvaluateExpression("b") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 445566) + + val = frame.EvaluateExpression("c") + self.assertTrue(val.IsValid()) + self.assertEqual(val.GetValueAsUnsigned(), 778899) + + def enable_expression_log(self): + log_file = os.path.join(self.getBuildDir(), "expr.log") + self.runCmd("log enable -f '%s' lldb expr" % (log_file)) + + def disable_expression_log_and_check_for_locals(self, variables): + log_file = os.path.join(self.getBuildDir(), "expr.log") + self.runCmd("log disable lldb expr") + local_var_regex = re.compile(r".*__lldb_local_vars::(.*);") + matched = [] + with open(log_file, 'r') as log: + for line in log: + if line.find('LLDB_BODY_START') != -1: + break + m = re.match(local_var_regex, line) + if m: + self.assertIn(m.group(1), variables) + matched.append(m.group(1)) + self.assertEqual([item for item in variables if item not in matched], + []) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/main.cpp new file mode 100644 index 00000000000..baf08f6a983 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/member-and-local-vars-with-same-name/main.cpp @@ -0,0 +1,73 @@ +namespace NN +{ + int a = 778899; + int b = 665544; + int c = 445566; +} + +class A +{ +public: + A(); + int Method(int a, int b); + +private: + int a, b; +}; + +A::A() : a(10), b(100) { } + +int a = 112233; +int b = 445566; +int c = 778899; + +int +A::Method(int a, int b) +{ + { + int a = 12345; + int b = 54321; + int c = 34567; + this->a = a + b + this->b; // Break 2 + } + + { + using namespace NN; + int a = 10001; + int b = 10002; + int c = 10003; + this->a = a + b + this->b; // Break 3 + } + + return this->a + this->b + a + b; // Break 4 +} + +int +Function(int a, int b) +{ + int A; + + { + int a = 12345; + int b = 54321; + int c = 34567; + A = a + b + c; // Break 5 + } + + { + using namespace NN; + int a = 10001; + int b = 10002; + int c = 10003; + A = a + b + c; // Break 6 + } + + return A + a + b; // Break 7 +} + +int +main() +{ + A obj; + return obj.Method(1, 2) + Function(1, 2); // Break 1 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/Bar.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/Bar.h new file mode 100644 index 00000000000..3d9a88c024d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/Bar.h @@ -0,0 +1 @@ +struct Bar { int success; }; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/Foo.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/Foo.h new file mode 100644 index 00000000000..1fe02e89786 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/Foo.h @@ -0,0 +1 @@ +struct Foo {}; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/module.modulemap b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/module.modulemap new file mode 100644 index 00000000000..4221d0f9134 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Inputs/module.modulemap @@ -0,0 +1,7 @@ +module Foo { + header "Foo.h" +} + +module Bar { + header "Bar.h" +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Makefile new file mode 100644 index 00000000000..3dff43b34c7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/Makefile @@ -0,0 +1,4 @@ +CXX_SOURCES := main.cpp +CXXFLAGS_EXTRAS = $(MANDATORY_MODULE_BUILD_CFLAGS) -I$(BUILDDIR)/include + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/TestCXXModulesImport.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/TestCXXModulesImport.py new file mode 100644 index 00000000000..e7f98c63b5e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/TestCXXModulesImport.py @@ -0,0 +1,45 @@ +"""Test that importing modules in C++ works as expected.""" + + +import unittest2 +import lldb +import shutil + +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CXXModulesImportTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def build(self): + include = self.getBuildArtifact('include') + lldbutil.mkdir_p(include) + for f in ['Foo.h', 'Bar.h', 'module.modulemap']: + shutil.copyfile(self.getSourcePath(os.path.join('Inputs', f)), + os.path.join(include, f)) + super(CXXModulesImportTestCase, self).build() + + @skipUnlessDarwin + @skipIf(macos_version=["<", "10.12"]) + def test_expr(self): + self.build() + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, 'break here', lldb.SBFileSpec('main.cpp')) + + self.expect("expr -l Objective-C++ -- @import Bar") + self.expect("expr -- Bar()", substrs = ["success"]) + self.expect("expr -l Objective-C++ -- @import THIS_MODULE_DOES_NOT_EXIST", + error=True) + + @skipUnlessDarwin + @skipIf(macos_version=["<", "10.12"]) + def test_expr_failing_import(self): + self.build() + shutil.rmtree(self.getBuildArtifact('include')) + target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( + self, 'break here', lldb.SBFileSpec('main.cpp')) + + self.expect("expr -l Objective-C++ -- @import Bar", error=True) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/main.cpp new file mode 100644 index 00000000000..a6acf9a1a69 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/modules-import/main.cpp @@ -0,0 +1,7 @@ +#include "Foo.h" + +int main(int argc, char **argv) { + Foo foo; + // break here. + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/Makefile new file mode 100644 index 00000000000..638974fafd6 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp ns.cpp ns2.cpp ns3.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py new file mode 100644 index 00000000000..2221755fad3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py @@ -0,0 +1,236 @@ +""" +Test the printing of anonymous and named namespace variables. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class NamespaceBreakpointTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureAll(bugnumber="llvm.org/pr28548", compiler="gcc") + @expectedFailureAll(oslist=["windows"]) + def test_breakpoints_func_auto(self): + """Test that we can set breakpoints correctly by basename to find all functions whose basename is "func".""" + self.build() + + names = [ + "func()", + "func(int)", + "A::B::func()", + "A::func()", + "A::func(int)"] + + # Create a target by the debugger. + exe = self.getBuildArtifact("a.out") + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + module_list = lldb.SBFileSpecList() + module_list.Append(lldb.SBFileSpec(exe, False)) + cu_list = lldb.SBFileSpecList() + # Set a breakpoint by name "func" which should pick up all functions + # whose basename is "func" + bp = target.BreakpointCreateByName( + "func", lldb.eFunctionNameTypeAuto, module_list, cu_list) + for bp_loc in bp: + name = bp_loc.GetAddress().GetFunction().GetName() + self.assertTrue( + name in names, + "make sure breakpoint locations are correct for 'func' with eFunctionNameTypeAuto") + + @expectedFailureAll(bugnumber="llvm.org/pr28548", compiler="gcc") + def test_breakpoints_func_full(self): + """Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "func" + (no namespaces).""" + self.build() + + names = ["func()", "func(int)"] + + # Create a target by the debugger. + exe = self.getBuildArtifact("a.out") + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + module_list = lldb.SBFileSpecList() + module_list.Append(lldb.SBFileSpec(exe, False)) + cu_list = lldb.SBFileSpecList() + + # Set a breakpoint by name "func" whose fullly qualified named matches "func" which + # should pick up only functions whose basename is "func" and has no + # containing context + bp = target.BreakpointCreateByName( + "func", lldb.eFunctionNameTypeFull, module_list, cu_list) + for bp_loc in bp: + name = bp_loc.GetAddress().GetFunction().GetName() + self.assertTrue( + name in names, + "make sure breakpoint locations are correct for 'func' with eFunctionNameTypeFull") + + def test_breakpoints_a_func_full(self): + """Test that we can set breakpoints correctly by fullname to find all functions whose fully qualified name is "A::func".""" + self.build() + + names = ["A::func()", "A::func(int)"] + + # Create a target by the debugger. + exe = self.getBuildArtifact("a.out") + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + module_list = lldb.SBFileSpecList() + module_list.Append(lldb.SBFileSpec(exe, False)) + cu_list = lldb.SBFileSpecList() + + # Set a breakpoint by name "A::func" whose fullly qualified named matches "A::func" which + # should pick up only functions whose basename is "func" and is + # contained in the "A" namespace + bp = target.BreakpointCreateByName( + "A::func", lldb.eFunctionNameTypeFull, module_list, cu_list) + for bp_loc in bp: + name = bp_loc.GetAddress().GetFunction().GetName() + self.assertTrue( + name in names, + "make sure breakpoint locations are correct for 'A::func' with eFunctionNameTypeFull") + + +class NamespaceTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line numbers for declarations of namespace variables i and + # j. + self.line_var_i = line_number( + 'main.cpp', '// Find the line number for anonymous namespace variable i.') + self.line_var_j = line_number( + 'main.cpp', '// Find the line number for named namespace variable j.') + # And the line number to break at. + self.line_break = line_number('main.cpp', + '// Set break point at this line.') + # Break inside do {} while and evaluate value + self.line_break_ns1 = line_number('main.cpp', '// Evaluate ns1::value') + self.line_break_ns2 = line_number('main.cpp', '// Evaluate ns2::value') + + def runToBkpt(self, command): + self.runCmd(command, RUN_SUCCEEDED) + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # rdar://problem/8668674 + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") + def test_with_run_command(self): + """Test that anonymous and named namespace variables display correctly.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "main.cpp", + self.line_break_ns1, + num_expected_locations=1, + loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, + "main.cpp", + self.line_break_ns2, + num_expected_locations=1, + loc_exact=True) + lldbutil.run_break_set_by_file_and_line( + self, + "main.cpp", + self.line_break, + num_expected_locations=1, + loc_exact=True) + + self.runToBkpt("run") + # Evaluate ns1::value + self.expect("expression -- value", startstr="(int) $0 = 100") + + self.runToBkpt("continue") + # Evaluate ns2::value + self.expect("expression -- value", startstr="(int) $1 = 200") + + self.runToBkpt("continue") + # On Mac OS X, gcc 4.2 emits the wrong debug info with respect to + # types. + slist = ['(int) a = 12', 'anon_uint', 'a_uint', 'b_uint', 'y_uint'] + if self.platformIsDarwin() and self.getCompiler() in [ + 'clang', 'llvm-gcc']: + slist = ['(int) a = 12', + '::my_uint_t', 'anon_uint = 0', + '(A::uint_t) a_uint = 1', + '(A::B::uint_t) b_uint = 2', + '(Y::uint_t) y_uint = 3'] + + # 'frame variable' displays the local variables with type information. + self.expect('frame variable', VARIABLES_DISPLAYED_CORRECTLY, + substrs=slist) + + # 'frame variable' with basename 'i' should work. + self.expect( + "frame variable --show-declaration --show-globals i", + startstr="main.cpp:%d: (int) (anonymous namespace)::i = 3" % + self.line_var_i) + # main.cpp:12: (int) (anonymous namespace)::i = 3 + + # 'frame variable' with basename 'j' should work, too. + self.expect( + "frame variable --show-declaration --show-globals j", + startstr="main.cpp:%d: (int) A::B::j = 4" % + self.line_var_j) + # main.cpp:19: (int) A::B::j = 4 + + # 'frame variable' should support address-of operator. + self.runCmd("frame variable &i") + + # 'frame variable' with fully qualified name 'A::B::j' should work. + self.expect("frame variable A::B::j", VARIABLES_DISPLAYED_CORRECTLY, + startstr='(int) A::B::j = 4', + patterns=[' = 4']) + + # So should the anonymous namespace case. + self.expect( + "frame variable '(anonymous namespace)::i'", + VARIABLES_DISPLAYED_CORRECTLY, + startstr='(int) (anonymous namespace)::i = 3', + patterns=[' = 3']) + + # rdar://problem/8660275 + # test/namespace: 'expression -- i+j' not working + # This has been fixed. + self.expect("expression -- i + j", + startstr="(int) $2 = 7") + # (int) $2 = 7 + + self.runCmd("expression -- i") + self.runCmd("expression -- j") + + # rdar://problem/8668674 + # expression command with fully qualified namespace for a variable does + # not work + self.expect("expression -- ::i", VARIABLES_DISPLAYED_CORRECTLY, + patterns=[' = 3']) + self.expect("expression -- A::B::j", VARIABLES_DISPLAYED_CORRECTLY, + patterns=[' = 4']) + + # expression command with function in anonymous namespace + self.expect("expression -- myanonfunc(3)", + patterns=[' = 6']) + + # global namespace qualification with function in anonymous namespace + self.expect("expression -- ::myanonfunc(4)", + patterns=[' = 8']) + + self.expect("p myanonfunc", + patterns=['\(anonymous namespace\)::myanonfunc\(int\)']) + + self.expect("p variadic_sum", patterns=[ + '\(anonymous namespace\)::variadic_sum\(int, ...\)']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py new file mode 100644 index 00000000000..5526a14f530 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py @@ -0,0 +1,314 @@ +""" +Test the printing of anonymous and named namespace variables. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class NamespaceLookupTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Break inside different scopes and evaluate value + self.line_break_global_scope = line_number( + 'ns.cpp', '// BP_global_scope') + self.line_break_file_scope = line_number('ns2.cpp', '// BP_file_scope') + self.line_break_ns_scope = line_number('ns2.cpp', '// BP_ns_scope') + self.line_break_nested_ns_scope = line_number( + 'ns2.cpp', '// BP_nested_ns_scope') + self.line_break_nested_ns_scope_after_using = line_number( + 'ns2.cpp', '// BP_nested_ns_scope_after_using') + self.line_break_before_using_directive = line_number( + 'ns3.cpp', '// BP_before_using_directive') + self.line_break_after_using_directive = line_number( + 'ns3.cpp', '// BP_after_using_directive') + + def runToBkpt(self, command): + self.runCmd(command, RUN_SUCCEEDED) + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + @expectedFailureAll( + oslist=["freebsd"], + bugnumber="llvm.org/pr25819") + @skipIfWindows # This is flakey on Windows: llvm.org/pr38373 + def test_scope_lookup_with_run_command(self): + """Test scope lookup of functions in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns.cpp", + self.line_break_global_scope, + num_expected_locations=1, + loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, + "ns2.cpp", + self.line_break_ns_scope, + num_expected_locations=1, + loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, + "ns2.cpp", + self.line_break_nested_ns_scope, + num_expected_locations=1, + loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, + "ns2.cpp", + self.line_break_nested_ns_scope_after_using, + num_expected_locations=1, + loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, + "ns3.cpp", + self.line_break_before_using_directive, + num_expected_locations=1, + loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, + "ns3.cpp", + self.line_break_after_using_directive, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_global_scope at global scope + self.runToBkpt("run") + # Evaluate func() - should call ::func() + self.expect("expr -- func()", startstr="(int) $0 = 1") + # Evaluate A::B::func() - should call A::B::func() + self.expect("expr -- A::B::func()", startstr="(int) $1 = 4") + # Evaluate func(10) - should call ::func(int) + self.expect("expr -- func(10)", startstr="(int) $2 = 11") + # Evaluate ::func() - should call A::func() + self.expect("expr -- ::func()", startstr="(int) $3 = 1") + # Evaluate A::foo() - should call A::foo() + self.expect("expr -- A::foo()", startstr="(int) $4 = 42") + + # Continue to BP_ns_scope at ns scope + self.runToBkpt("continue") + # Evaluate func(10) - should call A::func(int) + self.expect("expr -- func(10)", startstr="(int) $5 = 13") + # Evaluate B::func() - should call B::func() + self.expect("expr -- B::func()", startstr="(int) $6 = 4") + # Evaluate func() - should call A::func() + self.expect("expr -- func()", startstr="(int) $7 = 3") + + # Continue to BP_nested_ns_scope at nested ns scope + self.runToBkpt("continue") + # Evaluate func() - should call A::B::func() + self.expect("expr -- func()", startstr="(int) $8 = 4") + # Evaluate A::func() - should call A::func() + self.expect("expr -- A::func()", startstr="(int) $9 = 3") + + # Evaluate func(10) - should call A::func(10) + # NOTE: Under the rules of C++, this test would normally get an error + # because A::B::func() hides A::func(), but lldb intentionally + # disobeys these rules so that the intended overload can be found + # by only removing duplicates if they have the same type. + self.expect("expr -- func(10)", startstr="(int) $10 = 13") + + # Continue to BP_nested_ns_scope_after_using at nested ns scope after + # using declaration + self.runToBkpt("continue") + # Evaluate A::func(10) - should call A::func(int) + self.expect("expr -- A::func(10)", startstr="(int) $11 = 13") + + # Continue to BP_before_using_directive at global scope before using + # declaration + self.runToBkpt("continue") + # Evaluate ::func() - should call ::func() + self.expect("expr -- ::func()", startstr="(int) $12 = 1") + # Evaluate B::func() - should call B::func() + self.expect("expr -- B::func()", startstr="(int) $13 = 4") + + # Continue to BP_after_using_directive at global scope after using + # declaration + self.runToBkpt("continue") + # Evaluate ::func() - should call ::func() + self.expect("expr -- ::func()", startstr="(int) $14 = 1") + # Evaluate B::func() - should call B::func() + self.expect("expr -- B::func()", startstr="(int) $15 = 4") + + @unittest2.expectedFailure("lldb scope lookup of functions bugs") + def test_function_scope_lookup_with_run_command(self): + """Test scope lookup of functions in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns.cpp", + self.line_break_global_scope, + num_expected_locations=1, + loc_exact=False) + lldbutil.run_break_set_by_file_and_line( + self, + "ns2.cpp", + self.line_break_ns_scope, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_global_scope at global scope + self.runToBkpt("run") + # Evaluate foo() - should call ::foo() + # FIXME: lldb finds Y::foo because lookup for variables is done + # before functions. + self.expect("expr -- foo()", startstr="(int) $0 = 42") + # Evaluate ::foo() - should call ::foo() + # FIXME: lldb finds Y::foo because lookup for variables is done + # before functions and :: is ignored. + self.expect("expr -- ::foo()", startstr="(int) $1 = 42") + + # Continue to BP_ns_scope at ns scope + self.runToBkpt("continue") + # Evaluate foo() - should call A::foo() + # FIXME: lldb finds Y::foo because lookup for variables is done + # before functions. + self.expect("expr -- foo()", startstr="(int) $2 = 42") + + @unittest2.expectedFailure("lldb file scope lookup bugs") + @skipIfWindows # This is flakey on Windows: llvm.org/pr38373 + def test_file_scope_lookup_with_run_command(self): + """Test file scope lookup in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns2.cpp", + self.line_break_file_scope, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_file_scope at file scope + self.runToBkpt("run") + # Evaluate func() - should call static ns2.cpp:func() + # FIXME: This test fails because lldb doesn't know about file scopes so + # finds the global ::func(). + self.expect("expr -- func()", startstr="(int) $0 = 2") + + @skipIfWindows # This is flakey on Windows: llvm.org/pr38373 + def test_scope_lookup_before_using_with_run_command(self): + """Test scope lookup before using in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns3.cpp", + self.line_break_before_using_directive, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_before_using_directive at global scope before using + # declaration + self.runToBkpt("run") + # Evaluate func() - should call ::func() + self.expect("expr -- func()", startstr="(int) $0 = 1") + + # NOTE: this test may fail on older systems that don't emit import + # entries in DWARF - may need to add checks for compiler versions here. + @skipIf( + compiler="gcc", + oslist=["linux"], + debug_info=["dwo"]) # Skip to avoid crash + @expectedFailureAll( + oslist=["freebsd"], + bugnumber="llvm.org/pr25819") + def test_scope_after_using_directive_lookup_with_run_command(self): + """Test scope lookup after using directive in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns3.cpp", + self.line_break_after_using_directive, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_after_using_directive at global scope after using + # declaration + self.runToBkpt("run") + # Evaluate func2() - should call A::func2() + self.expect("expr -- func2()", startstr="(int) $0 = 3") + + @unittest2.expectedFailure( + "lldb scope lookup after using declaration bugs") + # NOTE: this test may fail on older systems that don't emit import + # emtries in DWARF - may need to add checks for compiler versions here. + def test_scope_after_using_declaration_lookup_with_run_command(self): + """Test scope lookup after using declaration in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns2.cpp", + self.line_break_nested_ns_scope_after_using, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_nested_ns_scope_after_using at nested ns scope after using + # declaration + self.runToBkpt("run") + # Evaluate func() - should call A::func() + self.expect("expr -- func()", startstr="(int) $0 = 3") + + @unittest2.expectedFailure("lldb scope lookup ambiguity after using bugs") + def test_scope_ambiguity_after_using_lookup_with_run_command(self): + """Test scope lookup ambiguity after using in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns3.cpp", + self.line_break_after_using_directive, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_after_using_directive at global scope after using + # declaration + self.runToBkpt("run") + # Evaluate func() - should get error: ambiguous + # FIXME: This test fails because lldb removes duplicates if they have + # the same type. + self.expect("expr -- func()", startstr="error") + + @expectedFailureAll( + oslist=["freebsd"], + bugnumber="llvm.org/pr25819") + def test_scope_lookup_shadowed_by_using_with_run_command(self): + """Test scope lookup shadowed by using in lldb.""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, + "ns2.cpp", + self.line_break_nested_ns_scope, + num_expected_locations=1, + loc_exact=False) + + # Run to BP_nested_ns_scope at nested ns scope + self.runToBkpt("run") + # Evaluate func(10) - should call A::func(10) + # NOTE: Under the rules of C++, this test would normally get an error + # because A::B::func() shadows A::func(), but lldb intentionally + # disobeys these rules so that the intended overload can be found + # by only removing duplicates if they have the same type. + self.expect("expr -- func(10)", startstr="(int) $0 = 13") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/cmds.txt b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/cmds.txt new file mode 100644 index 00000000000..76bb1bcba75 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/cmds.txt @@ -0,0 +1,3 @@ +b main.cpp:54 +c +var diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/main.cpp new file mode 100644 index 00000000000..22c0309695c --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/main.cpp @@ -0,0 +1,124 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <cstdarg> +#include <cstdlib> +#include "ns.h" + +namespace { + typedef unsigned int my_uint_t; + int i; // Find the line number for anonymous namespace variable i. + + int myanonfunc (int a) + { + return a + a; + } + + int + variadic_sum (int arg_count...) + { + int sum = 0; + std::va_list args; + va_start(args, arg_count); + + for (int i = 0; i < arg_count; i++) + sum += va_arg(args, int); + + va_end(args); + return sum; + } +} + +namespace A { + typedef unsigned int uint_t; + namespace B { + typedef unsigned int uint_t; + int j; // Find the line number for named namespace variable j. + int myfunc (int a); + int myfunc2(int a) + { + return a + 2; + } + float myfunc (float f) + { + return f - 2.0; + } + } +} + +namespace Y +{ + typedef unsigned int uint_t; + using A::B::j; + int foo; +} + +using A::B::j; // using declaration + +namespace Foo = A::B; // namespace alias + +using Foo::myfunc; // using declaration + +using namespace Foo; // using directive + +namespace A { + namespace B { + using namespace Y; + int k; + } +} + +namespace ns1 { + int value = 100; +} + +namespace ns2 { + int value = 200; +} + +void test_namespace_scopes() { + do { + using namespace ns1; + printf("ns1::value = %d\n", value); // Evaluate ns1::value + } while(0); + + do { + using namespace ns2; + printf("ns2::value = %d\n", value); // Evaluate ns2::value + } while(0); +} + +int Foo::myfunc(int a) +{ + test_namespace_scopes(); + + ::my_uint_t anon_uint = 0; + A::uint_t a_uint = 1; + B::uint_t b_uint = 2; + Y::uint_t y_uint = 3; + i = 3; + j = 4; + printf("::i=%d\n", ::i); + printf("A::B::j=%d\n", A::B::j); + printf("variadic_sum=%d\n", variadic_sum(3, 1, 2, 3)); + myanonfunc(3); + return myfunc2(3) + j + i + a + 2 + anon_uint + a_uint + b_uint + y_uint; // Set break point at this line. +} + +int +main (int argc, char const *argv[]) +{ + test_lookup_at_global_scope(); + test_lookup_at_file_scope(); + A::test_lookup_at_ns_scope(); + A::B::test_lookup_at_nested_ns_scope(); + A::B::test_lookup_at_nested_ns_scope_after_using(); + test_lookup_before_using_directive(); + test_lookup_after_using_directive(); + return Foo::myfunc(12); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.cpp new file mode 100644 index 00000000000..481a9866fcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.cpp @@ -0,0 +1,31 @@ +//===-- ns.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "ns.h" + +int foo() +{ + std::printf("global foo()\n"); + return 42; +} +int func() +{ + std::printf("global func()\n"); + return 1; +} +int func(int a) +{ + std::printf("global func(int)\n"); + return a + 1; +} +void test_lookup_at_global_scope() +{ + // BP_global_scope + std::printf("at global scope: foo() = %d\n", foo()); // eval foo(), exp: 42 + std::printf("at global scope: func() = %d\n", func()); // eval func(), exp: 1 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.h new file mode 100644 index 00000000000..d04b45a7d7a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.h @@ -0,0 +1,33 @@ +//===-- ns.h ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <cstdio> + +void test_lookup_at_global_scope(); +void test_lookup_at_file_scope(); +void test_lookup_before_using_directive(); +void test_lookup_after_using_directive(); +int func(int a); +namespace A { +int foo(); +int func(int a); +inline int func() { + std::printf("A::func()\n"); + return 3; +} +inline int func2() { + std::printf("A::func2()\n"); + return 3; +} +void test_lookup_at_ns_scope(); +namespace B { +int func(); +void test_lookup_at_nested_ns_scope(); +void test_lookup_at_nested_ns_scope_after_using(); +} // namespace B +} // namespace A diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns2.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns2.cpp new file mode 100644 index 00000000000..9aae5d0a495 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns2.cpp @@ -0,0 +1,64 @@ +//===-- ns2.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "ns.h" + +static int func() +{ + std::printf("static m2.cpp func()\n"); + return 2; +} +void test_lookup_at_file_scope() +{ + // BP_file_scope + std::printf("at file scope: func() = %d\n", func()); // eval func(), exp: 2 + std::printf("at file scope: func(10) = %d\n", func(10)); // eval func(10), exp: 11 +} +namespace A { + namespace B { + int func() + { + std::printf("A::B::func()\n"); + return 4; + } + void test_lookup_at_nested_ns_scope() + { + // BP_nested_ns_scope + std::printf("at nested ns scope: func() = %d\n", func()); // eval func(), exp: 4 + + //printf("func(10) = %d\n", func(10)); // eval func(10), exp: 13 + // NOTE: Under the rules of C++, this test would normally get an error + // because A::B::func() hides A::func(), but lldb intentionally + // disobeys these rules so that the intended overload can be found + // by only removing duplicates if they have the same type. + } + void test_lookup_at_nested_ns_scope_after_using() + { + // BP_nested_ns_scope_after_using + using A::func; + std::printf("at nested ns scope after using: func() = %d\n", func()); // eval func(), exp: 3 + } + } +} +int A::foo() +{ + std::printf("A::foo()\n"); + return 42; +} +int A::func(int a) +{ + std::printf("A::func(int)\n"); + return a + 3; +} +void A::test_lookup_at_ns_scope() +{ + // BP_ns_scope + std::printf("at nested ns scope: func() = %d\n", func()); // eval func(), exp: 3 + std::printf("at nested ns scope: func(10) = %d\n", func(10)); // eval func(10), exp: 13 + std::printf("at nested ns scope: foo() = %d\n", foo()); // eval foo(), exp: 42 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns3.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns3.cpp new file mode 100644 index 00000000000..0f7a5050fde --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace/ns3.cpp @@ -0,0 +1,26 @@ +//===-- ns3.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "ns.h" +extern int func(); + +// Note: the following function must be before the using. +void test_lookup_before_using_directive() +{ + // BP_before_using_directive + std::printf("before using directive: func() = %d\n", func()); // eval func(), exp: 1 +} +using namespace A; +void test_lookup_after_using_directive() +{ + // BP_after_using_directive + //printf("func() = %d\n", func()); // eval func(), exp: error, amiguous + std::printf("after using directive: func2() = %d\n", func2()); // eval func2(), exp: 3 + std::printf("after using directive: ::func() = %d\n", ::func()); // eval ::func(), exp: 1 + std::printf("after using directive: B::func() = %d\n", B::func()); // eval B::func(), exp: 4 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_conflicts/TestNamespaceConflicts.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_conflicts/TestNamespaceConflicts.py new file mode 100644 index 00000000000..c8308c16011 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_conflicts/TestNamespaceConflicts.py @@ -0,0 +1,4 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals()) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_conflicts/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_conflicts/main.cpp new file mode 100644 index 00000000000..0349365d843 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_conflicts/main.cpp @@ -0,0 +1,28 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +namespace n { + struct D { + int i; + static int anInt() { return 2; } + int dump() { return i; } + }; +} + +using namespace n; + +int foo(D* D) { + return D->dump(); //% self.expect("expression -- D->dump()", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["int", "2"]) +} + +int main (int argc, char const *argv[]) +{ + D myD { D::anInt() }; + foo(&myD); + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/Makefile new file mode 100644 index 00000000000..fc9165f67f4 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/Makefile @@ -0,0 +1,15 @@ +LD_EXTRAS := -L. -la -lb +CXX_SOURCES := main.cpp + +a.out: liba libb + +include Makefile.rules + +liba: + $(MAKE) -f $(MAKEFILE_RULES) \ + DYLIB_ONLY=YES DYLIB_NAME=a DYLIB_CXX_SOURCES=a.cpp + +libb: + $(MAKE) -f $(MAKEFILE_RULES) \ + DYLIB_ONLY=YES DYLIB_NAME=b DYLIB_CXX_SOURCES=b.cpp + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/TestNamespaceDefinitions.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/TestNamespaceDefinitions.py new file mode 100644 index 00000000000..e96a9fb93b7 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/TestNamespaceDefinitions.py @@ -0,0 +1,73 @@ +"""Test that forward declarations don't cause bogus conflicts in namespaced types""" + + + +import unittest2 +import lldb +from lldbsuite.test.lldbtest import * +from lldbsuite.test.decorators import * +import lldbsuite.test.lldbutil as lldbutil + + +class NamespaceDefinitionsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureAll( + bugnumber="llvm.org/pr28948", + compiler="gcc", + compiler_version=[ + "<", + "4.9"]) + @expectedFailureAll( + bugnumber="llvm.org/pr28948", + oslist=['linux'], compiler="gcc", archs=['arm','aarch64']) + @expectedFailureAll(oslist=["windows"]) + @expectedFailureNetBSD + def test_expr(self): + self.build() + self.common_setup() + + self.expect( + "expression -- Foo::MyClass()", + VARIABLES_DISPLAYED_CORRECTLY, + substrs=['thing = ']) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.source = 'main.cpp' + self.line = line_number(self.source, '// Set breakpoint here') + self.shlib_names = ["a", "b"] + + def common_setup(self): + # Run in synchronous mode + self.dbg.SetAsync(False) + + # Create a target by the debugger. + target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) + self.assertTrue(target, VALID_TARGET) + + # Break inside the foo function which takes a bar_ptr argument. + lldbutil.run_break_set_by_file_and_line( + self, self.source, self.line, num_expected_locations=1, loc_exact=True) + + # Register our shared libraries for remote targets so they get + # automatically uploaded + environment = self.registerSharedLibrariesWithTarget( + target, self.shlib_names) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, environment, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/a.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/a.cpp new file mode 100644 index 00000000000..2795b206e8e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/a.cpp @@ -0,0 +1,15 @@ +//===-- a.cpp ---------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "foo.h" + +class ThingInside { + int a; +}; + +Foo::MyClass a_class; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/b.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/b.cpp new file mode 100644 index 00000000000..b676865c4d2 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/b.cpp @@ -0,0 +1,11 @@ +//===-- b.cpp ---------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include "foo.h" + +Foo::MyClass b_class; diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/foo.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/foo.h new file mode 100644 index 00000000000..a2c64ab5928 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/foo.h @@ -0,0 +1,17 @@ +//===-- foo.h ---------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +class ThingInside; + +namespace Foo { + class MyClass { + ThingInside *thing; + public: + MyClass() { } + }; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/main.cpp new file mode 100644 index 00000000000..8703cd99246 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/namespace_definitions/main.cpp @@ -0,0 +1,15 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +int +main (int argc, char const *argv[]) +{ + return 0; // Set breakpoint here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/Makefile new file mode 100644 index 00000000000..020dce7c31d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp other.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/TestNestedClassWithParentInAnotherCU.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/TestNestedClassWithParentInAnotherCU.py new file mode 100644 index 00000000000..5b590d6363a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/TestNestedClassWithParentInAnotherCU.py @@ -0,0 +1,29 @@ +""" +Test that the expression evaluator can access members of nested classes even if +the parents of the nested classes were imported from another compilation unit. +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestNestedClassWithParentInAnotherCU(TestBase): + mydir = TestBase.compute_mydir(__file__) + + def test_nested_class_with_parent_in_another_cu(self): + self.main_source_file = lldb.SBFileSpec("main.cpp") + self.build() + (_, _, thread, _) = lldbutil.run_to_source_breakpoint(self, "// break here", self.main_source_file) + frame = thread.GetSelectedFrame() + # Parse the DIEs of the parent classes and the nested classes from + # other.cpp's CU. + warmup_result = frame.EvaluateExpression("b") + self.assertTrue(warmup_result.IsValid()) + # Inspect fields of the nested classes. This will reuse the types that + # were parsed during the evaluation above. By accessing a chain of + # fields, we try to verify that all the DIEs, reused types and + # declaration contexts were wired properly into lldb's parser's state. + expr_result = frame.EvaluateExpression("a.y.oY_inner.oX_inner") + self.assertTrue(expr_result.IsValid()) + self.assertEqual(expr_result.GetValue(), "42") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/main.cpp new file mode 100644 index 00000000000..8a6e6ff81d2 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/main.cpp @@ -0,0 +1,22 @@ +#include "shared.h" + +struct WrapperA { + OuterY::Inner<unsigned int> y; +}; + +int main() { + // WrapperA refers to the Inner and Outer class DIEs from this CU. + WrapperA a; + // WrapperB refers to the Inner and Outer DIEs from the other.cpp CU. + // It is important that WrapperB is only forward-declared in shared.h. + WrapperB* b = foo(); + + // Evaluating 'b' here will parse other.cpp's DIEs for all + // the Inner and Outer classes from shared.h. + // + // Evaluating 'a' here will find and reuse the already-parsed + // versions of the Inner and Outer classes. In the associated test + // we make sure that we can still resolve all the types properly + // by evaluating 'a.y.oY_inner.oX_inner'. + return 0; // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/other.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/other.cpp new file mode 100644 index 00000000000..71a9579c4e8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/other.cpp @@ -0,0 +1,10 @@ +#include "shared.h" + +struct WrapperB { + OuterY y; + OuterX x; +}; + +WrapperB* foo() { + return new WrapperB(); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/shared.h b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/shared.h new file mode 100644 index 00000000000..627f49ab79c --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nested-class-other-compilation-unit/shared.h @@ -0,0 +1,17 @@ +struct OuterX { + template<typename T> + struct Inner { + int oX_inner = 42; + }; +}; + +struct OuterY { + template<typename T> + struct Inner { + typename OuterX::Inner<T> oY_inner; + }; +}; + +struct WrapperB; + +WrapperB* foo(); diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py new file mode 100644 index 00000000000..f42d194cd62 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py @@ -0,0 +1,136 @@ +""" +Tests imported namespaces in C++. +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestCppNsImport(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_with_run_command(self): + """Tests imported namespaces in C++.""" + self.build() + + # Get main source file + src_file = os.path.join(self.getSourceDir(), "main.cpp") + src_file_spec = lldb.SBFileSpec(src_file) + self.assertTrue(src_file_spec.IsValid(), "Main source file") + + # Get the path of the executable + exe_path = self.getBuildArtifact("a.out") + + # Load the executable + target = self.dbg.CreateTarget(exe_path) + self.assertTrue(target.IsValid(), VALID_TARGET) + + # Break on main function + break_0 = target.BreakpointCreateBySourceRegex( + "// break 0", src_file_spec) + self.assertTrue( + break_0.IsValid() and break_0.GetNumLocations() >= 1, + VALID_BREAKPOINT) + break_1 = target.BreakpointCreateBySourceRegex( + "// break 1", src_file_spec) + self.assertTrue( + break_1.IsValid() and break_1.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + args = None + env = None + process = target.LaunchSimple( + args, env, self.get_process_working_directory()) + self.assertTrue(process.IsValid(), PROCESS_IS_VALID) + + # Get the thread of the process + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + + # Get current fream of the thread at the breakpoint + frame = thread.GetSelectedFrame() + + # Test imported namespaces + test_result = frame.EvaluateExpression("n") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 1, + "n = 1") + + test_result = frame.EvaluateExpression("N::n") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 1, + "N::n = 1") + + test_result = frame.EvaluateExpression("nested") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 3, + "nested = 3") + + test_result = frame.EvaluateExpression("anon") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 2, + "anon = 2") + + test_result = frame.EvaluateExpression("global") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 4, + "global = 4") + + test_result = frame.EvaluateExpression("fun_var") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 9, + "fun_var = 9") + + test_result = frame.EvaluateExpression("Fun::fun_var") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 0, + "Fun::fun_var = 0") + + test_result = frame.EvaluateExpression("not_imported") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 35, + "not_imported = 35") + + # Currently there is no way to distinguish between "::imported" and "imported" in ClangExpressionDeclMap so this fails + #test_result = frame.EvaluateExpression("::imported") + #self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 89, "::imported = 89") + + test_result = frame.EvaluateExpression("Imported::imported") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 99, + "Imported::imported = 99") + + test_result = frame.EvaluateExpression("imported") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 99, + "imported = 99") + + test_result = frame.EvaluateExpression("single") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 3, + "single = 3") + + # Continue to second breakpoint + process.Continue() + + # Get the thread of the process + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + + # Get current fream of the thread at the breakpoint + frame = thread.GetSelectedFrame() + + # Test function inside namespace + test_result = frame.EvaluateExpression("fun_var") + self.assertTrue( + test_result.IsValid() and test_result.GetValueAsSigned() == 5, + "fun_var = 5") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/main.cpp new file mode 100644 index 00000000000..e125ebaa243 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/nsimport/main.cpp @@ -0,0 +1,72 @@ +namespace N +{ + int n; +} + +namespace +{ + int anon; +} + +namespace Nested +{ + namespace + { + int nested; + } +} + +namespace Global +{ + int global; +} + +namespace Fun +{ + int fun_var; + int fun() + { + fun_var = 5; + return 0; // break 1 + } +} + +namespace Single +{ + int single = 3; +} + +namespace NotImportedBefore +{ + int not_imported = 45; +} + +using namespace Global; + +int not_imported = 35; +int fun_var = 9; + +namespace NotImportedAfter +{ + int not_imported = 55; +} + +namespace Imported +{ + int imported = 99; +} + +int imported = 89; + +int main() +{ + using namespace N; + using namespace Nested; + using namespace Imported; + using Single::single; + n = 1; + anon = 2; + nested = 3; + global = 4; + return Fun::fun(); // break 0 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/offsetof/TestOffsetofCpp.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/offsetof/TestOffsetofCpp.py new file mode 100644 index 00000000000..cdfbaae0ce3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/offsetof/TestOffsetofCpp.py @@ -0,0 +1,4 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals(), [decorators.no_debug_info_test]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/offsetof/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/offsetof/main.cpp new file mode 100644 index 00000000000..ab379f839c8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/offsetof/main.cpp @@ -0,0 +1,25 @@ +#include <cstdint> + +class Base { + int32_t a; +}; +class Class1 : Base { +public: + int32_t b; +}; + +class EmptyBase { +}; +class Class2 : EmptyBase { +public: + int32_t b; +}; + +int main(int argc, char **argv) { + Class1 c1; + Class2 c2; + //% self.expect("expr offsetof(Base, a)", substrs=["= 0"]) + //% self.expect("expr offsetof(Class1, b)", substrs=["= 4"]) + //% self.expect("expr offsetof(Class2, b)", substrs=["= 0"]) + return c1.b + c2.b; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/Makefile new file mode 100644 index 00000000000..80b3ee02c3e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/Makefile @@ -0,0 +1,6 @@ +CXX_SOURCES = a.cpp b.cpp + +include Makefile.rules + +a.o: a.cpp + $(CC) $(CFLAGS_NO_DEBUG) -c $< -o $@ diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/TestOperatorOverload.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/TestOperatorOverload.py new file mode 100644 index 00000000000..f541a6617e3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/TestOperatorOverload.py @@ -0,0 +1,22 @@ +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + +class TestOperatorOverload(TestBase): + mydir = TestBase.compute_mydir(__file__) + + def test_overload(self): + self.build() + (target, process, thread, + main_breakpoint) = lldbutil.run_to_source_breakpoint(self, + "break here", lldb.SBFileSpec("b.cpp")) + frame = thread.GetSelectedFrame() + value = frame.EvaluateExpression("x == nil") + self.assertTrue(str(value.GetError()) + .find("comparison between NULL and non-pointer ('Tinky' and NULL)") + != -1) + self.assertTrue(str(value.GetError()) + .find("invalid operands to binary expression ('Tinky' and") + != -1) + self.assertFalse(value.GetError().Success()) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/a.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/a.cpp new file mode 100644 index 00000000000..77b2f6ace82 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/a.cpp @@ -0,0 +1,9 @@ +class Patatino { +public: + double _blah; + Patatino(int blah) : _blah(blah) {} +}; + +bool operator==(const Patatino& a, const Patatino& b) { + return a._blah < b._blah; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/b.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/b.cpp new file mode 100644 index 00000000000..c0eb29bb79f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operator-overload/b.cpp @@ -0,0 +1,10 @@ +class Tinky { +public: + int _meh; + Tinky(int meh) : _meh(meh) {} +}; + +int main(void) { + Tinky x(12); + return 0; // break here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operators/TestCppOperators.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operators/TestCppOperators.py new file mode 100644 index 00000000000..c8308c16011 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operators/TestCppOperators.py @@ -0,0 +1,4 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals()) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operators/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operators/main.cpp new file mode 100644 index 00000000000..892d0bae42a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/operators/main.cpp @@ -0,0 +1,181 @@ +#include <cstdlib> + +int side_effect = 0; + +struct B { int dummy = 2324; }; +struct C { + void *operator new(size_t size) { C* r = ::new C; r->custom_new = true; return r; } + void *operator new[](size_t size) { C* r = static_cast<C*>(std::malloc(size)); r->custom_new = true; return r; } + void operator delete(void *p) { std::free(p); side_effect = 1; } + void operator delete[](void *p) { std::free(p); side_effect = 2; } + + bool custom_new = false; + B b; + B* operator->() { return &b; } + int operator->*(int) { return 2; } + int operator+(int) { return 44; } + int operator+=(int) { return 42; } + int operator++(int) { return 123; } + int operator++() { return 1234; } + int operator-(int) { return 34; } + int operator-=(int) { return 32; } + int operator--() { return 321; } + int operator--(int) { return 4321; } + + int operator*(int) { return 51; } + int operator*=(int) { return 52; } + int operator%(int) { return 53; } + int operator%=(int) { return 54; } + int operator/(int) { return 55; } + int operator/=(int) { return 56; } + int operator^(int) { return 57; } + int operator^=(int) { return 58; } + + int operator|(int) { return 61; } + int operator|=(int) { return 62; } + int operator||(int) { return 63; } + int operator&(int) { return 64; } + int operator&=(int) { return 65; } + int operator&&(int) { return 66; } + + int operator~() { return 71; } + int operator!() { return 72; } + int operator!=(int) { return 73; } + int operator=(int) { return 74; } + int operator==(int) { return 75; } + + int operator<(int) { return 81; } + int operator<<(int) { return 82; } + int operator<=(int) { return 83; } + int operator<<=(int) { return 84; } + int operator>(int) { return 85; } + int operator>>(int) { return 86; } + int operator>=(int) { return 87; } + int operator>>=(int) { return 88; } + + int operator,(int) { return 2012; } + int operator&() { return 2013; } + + int operator()(int) { return 91; } + int operator[](int) { return 92; } + + operator int() { return 11; } + operator long() { return 12; } + + // Make sure this doesn't collide with + // the real operator int. + int operatorint() { return 13; } + int operatornew() { return 14; } +}; + +int main(int argc, char **argv) { + C c; + int result = c->dummy; + result = c->*4; + result += c+1; + result += c+=1; + result += c++; + result += ++c; + result += c-1; + result += c-=1; + result += c--; + result += --c; + + result += c * 4; + result += c *= 4; + result += c % 4; + result += c %= 4; + result += c / 4; + result += c /= 4; + result += c ^ 4; + result += c ^= 4; + + result += c | 4; + result += c |= 4; + result += c || 4; + result += c & 4; + result += c &= 4; + result += c && 4; + + result += ~c; + result += !c; + result += c!=1; + result += c=2; + result += c==2; + + result += c<2; + result += c<<2; + result += c<=2; + result += c<<=2; + result += c>2; + result += c>>2; + result += c>=2; + result += c>>=2; + + result += (c , 2); + result += &c; + + result += c(1); + result += c[1]; + + result += static_cast<int>(c); + result += static_cast<long>(c); + result += c.operatorint(); + result += c.operatornew(); + + C *c2 = new C(); + C *c3 = new C[3]; + + //% self.expect("expr c->dummy", endstr=" 2324\n") + //% self.expect("expr c->*2", endstr=" 2\n") + //% self.expect("expr c + 44", endstr=" 44\n") + //% self.expect("expr c += 42", endstr=" 42\n") + //% self.expect("expr c++", endstr=" 123\n") + //% self.expect("expr ++c", endstr=" 1234\n") + //% self.expect("expr c - 34", endstr=" 34\n") + //% self.expect("expr c -= 32", endstr=" 32\n") + //% self.expect("expr c--", endstr=" 4321\n") + //% self.expect("expr --c", endstr=" 321\n") + //% self.expect("expr c * 3", endstr=" 51\n") + //% self.expect("expr c *= 3", endstr=" 52\n") + //% self.expect("expr c % 3", endstr=" 53\n") + //% self.expect("expr c %= 3", endstr=" 54\n") + //% self.expect("expr c / 3", endstr=" 55\n") + //% self.expect("expr c /= 3", endstr=" 56\n") + //% self.expect("expr c ^ 3", endstr=" 57\n") + //% self.expect("expr c ^= 3", endstr=" 58\n") + //% self.expect("expr c | 3", endstr=" 61\n") + //% self.expect("expr c |= 3", endstr=" 62\n") + //% self.expect("expr c || 3", endstr=" 63\n") + //% self.expect("expr c & 3", endstr=" 64\n") + //% self.expect("expr c &= 3", endstr=" 65\n") + //% self.expect("expr c && 3", endstr=" 66\n") + //% self.expect("expr ~c", endstr=" 71\n") + //% self.expect("expr !c", endstr=" 72\n") + //% self.expect("expr c!=1", endstr=" 73\n") + //% self.expect("expr c=1", endstr=" 74\n") + //% self.expect("expr c==1", endstr=" 75\n") + //% self.expect("expr c<1", endstr=" 81\n") + //% self.expect("expr c<<1", endstr=" 82\n") + //% self.expect("expr c<=1", endstr=" 83\n") + //% self.expect("expr c<<=1", endstr=" 84\n") + //% self.expect("expr c>1", endstr=" 85\n") + //% self.expect("expr c>>1", endstr=" 86\n") + //% self.expect("expr c>=1", endstr=" 87\n") + //% self.expect("expr c>>=1", endstr=" 88\n") + //% self.expect("expr c,1", endstr=" 2012\n") + //% self.expect("expr &c", endstr=" 2013\n") + //% self.expect("expr c(1)", endstr=" 91\n") + //% self.expect("expr c[1]", endstr=" 92\n") + //% self.expect("expr static_cast<int>(c)", endstr=" 11\n") + //% self.expect("expr static_cast<long>(c)", endstr=" 12\n") + //% self.expect("expr c.operatorint()", endstr=" 13\n") + //% self.expect("expr c.operatornew()", endstr=" 14\n") + //% self.expect("expr (new C)->custom_new", endstr=" true\n") + //% self.expect("expr (new struct C[1])->custom_new", endstr=" true\n") + //% self.expect("expr delete c2; side_effect", endstr=" = 1\n") + //% self.expect("expr delete[] c3; side_effect", endstr=" = 2\n") + delete c2; + delete[] c3; + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/Makefile new file mode 100644 index 00000000000..1185ed0c1e8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp static-a.cpp static-b.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py new file mode 100644 index 00000000000..ad969ef3d08 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py @@ -0,0 +1,38 @@ +""" +Tests that functions with the same name are resolved correctly. +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class OverloadedFunctionsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + TestBase.setUp(self) + self.line = line_number('main.cpp', '// breakpoint') + + def test_with_run_command(self): + """Test that functions with the same name are resolved correctly""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("process launch", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", + STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', 'stop reason = breakpoint']) + + self.expect("expression -- Dump(myB)", + startstr="(int) $0 = 2") + + self.expect("expression -- Static()", + startstr="(int) $1 = 1") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/main.cpp new file mode 100644 index 00000000000..250e2cd1d96 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/main.cpp @@ -0,0 +1,43 @@ +#include <stdio.h> + +struct A { + int aa; + char ab; +}; + +struct B { + int ba; + int bb; +}; + +struct C { + int ca; + int cb; +}; + +int Dump (A &a) +{ + return 1; +} + +int Dump (B &b) +{ + return 2; +} + +int Dump (C &c) +{ + return 3; +} + +extern int CallStaticA(); +extern int CallStaticB(); + +int main() +{ + A myA; + B myB; + C myC; + + printf("%d\n", CallStaticA() + CallStaticB()); // breakpoint +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-a.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-a.cpp new file mode 100644 index 00000000000..7250fa4bed5 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-a.cpp @@ -0,0 +1,9 @@ +static int Static() +{ + return 1; +} + +int CallStaticA() +{ + return Static(); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-b.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-b.cpp new file mode 100644 index 00000000000..90a20f69e6d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-b.cpp @@ -0,0 +1,9 @@ +static int Static() +{ + return 1; +} + +int CallStaticB() +{ + return Static(); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/printf/TestPrintf.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/printf/TestPrintf.py new file mode 100644 index 00000000000..10e400f4e72 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/printf/TestPrintf.py @@ -0,0 +1,8 @@ +from lldbsuite.test import lldbinline, lldbplatformutil +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest( + __file__, globals(), [ + decorators.expectedFailureAll( + bugnumber="llvm.org/PR36715", + oslist=lldbplatformutil.getDarwinOSTriples()+['windows'])]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/printf/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/printf/main.cpp new file mode 100644 index 00000000000..27395eb6f41 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/printf/main.cpp @@ -0,0 +1,20 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +class PrintfContainer { +public: + int printf() { + return 0; + } +}; + +int main() { + PrintfContainer().printf(); //% self.expect("expression -- printf(\"Hello\\n\")", substrs = ['6']) + return 0; +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/Makefile new file mode 100644 index 00000000000..e891bb25dd9 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/Makefile @@ -0,0 +1,5 @@ +CXX_SOURCES := main.cpp + +CXXFLAGS_EXTRAS := -std=c++11 + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py new file mode 100644 index 00000000000..5e31d93eb16 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py @@ -0,0 +1,53 @@ +""" +Tests that rvalue references are supported in C++ +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class RvalueReferencesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + # rdar://problem/11479676 + @expectedFailureAll( + compiler="icc", + bugnumber="ICC (13.1, 14-beta) do not emit DW_TAG_rvalue_reference_type.") + def test_with_run_command(self): + """Test that rvalues are supported in the C++ expression parser""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) + self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) + + self.runCmd("process launch", RUN_SUCCEEDED) + + # Note that clang as of r187480 doesn't emit DW_TAG_const_type, unlike gcc 4.8.1 + # With gcc 4.8.1, lldb reports the type as (int &&const) + self.expect("frame variable i", + startstr="(int &&", + substrs=["i = 0x", "&i = 3"]) + + self.expect("expression -- i", + startstr="(int) ", + substrs=["3"]) + + self.expect("breakpoint delete 1") + + self.runCmd("process continue") + + self.expect("expression -- foo(2)") + + self.expect("expression -- int &&j = 3; foo(j)", + error=True) + + self.expect("expression -- int &&k = 6; k", + startstr="(int) $1 = 6") + + def set_breakpoint(self, line): + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=1, loc_exact=True) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/main.cpp new file mode 100644 index 00000000000..6da34c73f10 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/main.cpp @@ -0,0 +1,12 @@ +#include <stdio.h> + +void foo (int &&i) +{ + printf("%d\n", i); // breakpoint 1 +} + +int main() +{ + foo(3); + return 0; // breakpoint 2 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py new file mode 100644 index 00000000000..213e7fbe902 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py @@ -0,0 +1,91 @@ +""" +Test scopes in C++. +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestCppScopes(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") + def test_all_but_c(self): + self.do_test(False) + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764") + def test_c(self): + self.do_test(True) + + def do_test(self, test_c): + self.build() + + # Get main source file + src_file = os.path.join(self.getSourceDir(), "main.cpp") + src_file_spec = lldb.SBFileSpec(src_file) + self.assertTrue(src_file_spec.IsValid(), "Main source file") + + # Get the path of the executable + exe_path = self.getBuildArtifact("a.out") + + # Load the executable + target = self.dbg.CreateTarget(exe_path) + self.assertTrue(target.IsValid(), VALID_TARGET) + + # Break on main function + main_breakpoint = target.BreakpointCreateBySourceRegex( + "// break here", src_file_spec) + self.assertTrue( + main_breakpoint.IsValid() and main_breakpoint.GetNumLocations() >= 1, + VALID_BREAKPOINT) + + # Launch the process + args = None + env = None + process = target.LaunchSimple( + args, env, self.get_process_working_directory()) + self.assertTrue(process.IsValid(), PROCESS_IS_VALID) + + # Get the thread of the process + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + + # Get current fream of the thread at the breakpoint + frame = thread.GetSelectedFrame() + + # Test result for scopes of variables + + global_variables = frame.GetVariables(True, True, True, False) + global_variables_assert = { + 'A::a': 1111, + 'B::a': 2222, + 'C::a': 3333, + '::a': 4444, + 'a': 4444 + } + + self.assertTrue( + global_variables.GetSize() == 4, + "target variable returns all variables") + for variable in global_variables: + name = variable.GetName() + self.assertTrue( + name in global_variables_assert, + "target variable returns wrong variable " + name) + + for name in global_variables_assert: + if name is "C::a" and not test_c: + continue + if name is not "C::a" and test_c: + continue + + value = frame.EvaluateExpression(name) + assert_value = global_variables_assert[name] + self.assertTrue( + value.IsValid() and value.GetValueAsSigned() == assert_value, + name + " = " + str(assert_value)) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/main.cpp new file mode 100644 index 00000000000..da5d7ed529d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/scope/main.cpp @@ -0,0 +1,25 @@ +class A { +public: + static int a; + int b; +}; + +class B { +public: + static int a; + int b; +}; + +struct C { + static int a; +}; + +int A::a = 1111; +int B::a = 2222; +int C::a = 3333; +int a = 4444; + +int main() // break here +{ + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py new file mode 100644 index 00000000000..f61cd64130d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py @@ -0,0 +1,66 @@ +""" +Test that variables with signed types display correctly. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class SignedTypesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.source = 'main.cpp' + self.line = line_number( + self.source, '// Set break point at this line.') + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489") + def test(self): + """Test that variables with signed types display correctly.""" + self.build() + + # Run in synchronous mode + self.dbg.SetAsync(False) + + # Create a target by the debugger. + target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) + self.assertTrue(target, VALID_TARGET) + + lldbutil.run_break_set_by_file_and_line( + self, self.source, self.line, num_expected_locations=1, loc_exact=True) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) + + # Execute the puts(). + self.runCmd("thread step-over") + + # Test that signed types display correctly. + self.expect( + "frame variable --show-types --no-args", + VARIABLES_DISPLAYED_CORRECTLY, + patterns=[ + "\((short int|short)\) the_signed_short = 99", + "\((signed char|char)\) the_signed_char = 'c'"], + substrs=[ + "(int) the_signed_int = 99", + "(long) the_signed_long = 99", + "(long long) the_signed_long_long = 99"]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/main.cpp new file mode 100644 index 00000000000..4f180bbbd13 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/signed_types/main.cpp @@ -0,0 +1,32 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include <stdio.h> + +int main (int argc, char const *argv[]) +{ + char the_char = 'c'; + short the_short = 'c'; + wchar_t the_wchar_t = 'c'; + int the_int = 'c'; + long the_long = 'c'; + long long the_long_long = 'c'; + + signed char the_signed_char = 'c'; + signed short the_signed_short = 'c'; + signed int the_signed_int = 'c'; + signed long the_signed_long = 'c'; + signed long long the_signed_long_long = 'c'; + puts(""); // Set break point at this line. + return the_char - the_signed_char + + the_short - the_signed_short + + the_int - the_signed_int + + the_long - the_signed_long + + the_long_long - the_signed_long_long; //// break $source:$line; c + //// var the_int + //// val -set 22 1 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py new file mode 100644 index 00000000000..4e02ebe8965 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py @@ -0,0 +1,61 @@ +""" +Tests that C++ member and static variables have correct layout and scope. +""" + + + +import unittest2 +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CPPStaticMembersTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @unittest2.expectedFailure # llvm.org/pr15401 + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr21765") + def test_with_run_command(self): + """Test that member variables have the correct layout, scope and qualifiers when stopped inside and outside C++ methods""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) + self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) + + self.runCmd("process launch", RUN_SUCCEEDED) + self.expect("expression my_a.access()", + startstr="(long) $0 = 10") + + self.expect("expression my_a.m_a", + startstr="(short) $1 = 1") + + # Note: SymbolFileDWARF::ParseChildMembers doesn't call + # AddFieldToRecordType, consistent with clang's AST layout. + self.expect("expression my_a.s_d", + startstr="(int) $2 = 4") + + self.expect("expression my_a.s_b", + startstr="(long) $3 = 2") + + self.expect("expression A::s_b", + startstr="(long) $4 = 2") + + # should not be available in global scope + self.expect("expression s_d", + startstr="error: use of undeclared identifier 's_d'") + + self.runCmd("process continue") + self.expect("expression m_c", + startstr="(char) $5 = \'\\x03\'") + + self.expect("expression s_b", + startstr="(long) $6 = 2") + + self.runCmd("process continue") + + def set_breakpoint(self, line): + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=1, loc_exact=False) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/main.cpp new file mode 100644 index 00000000000..ab8ae1b645f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_members/main.cpp @@ -0,0 +1,35 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +struct A +{ + short m_a; + static long s_b; + char m_c; + static int s_d; + + long access() { + return m_a + s_b + m_c + s_d; // breakpoint 2 + } +}; + +long A::s_b = 2; +int A::s_d = 4; + +int main() +{ + A my_a; + my_a.m_a = 1; + my_a.m_c = 3; + + my_a.access(); // breakpoint 1 + return 0; +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py new file mode 100644 index 00000000000..4b422674134 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py @@ -0,0 +1,38 @@ +""" +Tests expressions that distinguish between static and non-static methods. +""" + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CPPStaticMethodsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + TestBase.setUp(self) + self.line = line_number('main.cpp', '// Break at this line') + + def test_with_run_command(self): + """Test that static methods are properly distinguished from regular methods""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("process launch", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", + STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', 'stop reason = breakpoint']) + + self.expect("expression -- A::getStaticValue()", + startstr="(int) $0 = 5") + + self.expect("expression -- my_a.getMemberValue()", + startstr="(int) $1 = 3") diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/main.cpp new file mode 100644 index 00000000000..4c57e09296c --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/static_methods/main.cpp @@ -0,0 +1,37 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +class A +{ +public: + static int getStaticValue(); + int getMemberValue(); + int a; +}; + +int A::getStaticValue() +{ + return 5; +} + +int A::getMemberValue() +{ + return a; +} + +int main() +{ + A my_a; + + my_a.a = 3; + + printf("%d\n", A::getStaticValue()); // Break at this line + printf("%d\n", my_a.getMemberValue()); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/Makefile new file mode 100644 index 00000000000..b016f006747 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/Makefile @@ -0,0 +1,5 @@ +CXX_SOURCES := main.cpp +CXXFLAGS_EXTRAS := -std=c++11 +USE_LIBCPP := 1 + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/TestStdFunctionStepIntoCallable.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/TestStdFunctionStepIntoCallable.py new file mode 100644 index 00000000000..d667321493e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/TestStdFunctionStepIntoCallable.py @@ -0,0 +1,71 @@ +""" +Test stepping into std::function +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class LibCxxFunctionSteppingIntoCallableTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + NO_DEBUG_INFO_TESTCASE = True + + @add_test_categories(["libc++"]) + def test(self): + """Test that std::function as defined by libc++ is correctly printed by LLDB""" + self.build() + + self.main_source = "main.cpp" + self.main_source_spec = lldb.SBFileSpec(self.main_source) + self.source_foo_line = line_number( + self.main_source, '// Source foo start line') + self.source_lambda_f2_line = line_number( + self.main_source, '// Source lambda used by f2 start line') + self.source_lambda_f3_line = line_number( + self.main_source, '// Source lambda used by f3 start line') + self.source_bar_operator_line = line_number( + self.main_source, '// Source Bar::operator()() start line') + self.source_bar_add_num_line = line_number( + self.main_source, '// Source Bar::add_num start line') + self.source_main_invoking_f1 = line_number( + self.main_source, '// Source main invoking f1') + + (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint( + self, "// Set break point at this line.", self.main_source_spec) + + thread.StepInto() + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.source_main_invoking_f1 ) ; + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetFileSpec().GetFilename(), self.main_source) ; + + thread.StepInto() + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.source_foo_line ) ; + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetFileSpec().GetFilename(), self.main_source) ; + process.Continue() + + thread.StepInto() + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.source_lambda_f2_line ) ; + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetFileSpec().GetFilename(), self.main_source) ; + process.Continue() + + thread.StepInto() + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.source_lambda_f3_line ) ; + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetFileSpec().GetFilename(), self.main_source) ; + process.Continue() + + # TODO reenable this case when std::function formatter supports + # general callable object case. + #thread.StepInto() + #self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.source_bar_operator_line ) ; + #self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetFileSpec().GetFilename(), self.main_source) ; + #process.Continue() + + thread.StepInto() + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetLine(), self.source_bar_add_num_line ) ; + self.assertEqual( thread.GetFrameAtIndex(0).GetLineEntry().GetFileSpec().GetFilename(), self.main_source) ; + process.Continue() diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/main.cpp new file mode 100644 index 00000000000..ebbb05e6d13 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/std-function-step-into-callable/main.cpp @@ -0,0 +1,40 @@ +#include <functional> + +int foo(int x, int y) { + return x + y - 1; // Source foo start line +} + +struct Bar { + int operator()() { + return 66 ; // Source Bar::operator()() start line + } + int add_num(int i) const { return i + 3 ; } // Source Bar::add_num start line + int num_ = 0 ; +} ; + +int main (int argc, char *argv[]) +{ + int acc = 42; + std::function<int (int,int)> f1 = foo; + std::function<int (int)> f2 = [acc,f1] (int x) -> int { + return x+f1(acc,x); // Source lambda used by f2 start line + }; + + auto f = [](int x, int y) { return x + y; }; // Source lambda used by f3 start line + auto g = [](int x, int y) { return x * y; } ; + std::function<int (int,int)> f3 = argc %2 ? f : g ; + + Bar bar1 ; + std::function<int ()> f4( bar1 ) ; + std::function<int (const Bar&, int)> f5 = &Bar::add_num; + std::function<int(Bar const&)> f_mem = &Bar::num_; + + return f_mem(bar1) + // Set break point at this line. + f1(acc,acc) + // Source main invoking f1 + f2(acc) + // Set break point at this line. + f3(acc+1,acc+2) + // Set break point at this line. + // TODO reenable this case when std::function formatter supports + // general callable object case. + //f4() + // Set break point at this line. + f5(bar1, 10); // Set break point at this line. +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/Makefile new file mode 100644 index 00000000000..a4b03ae0aab --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/Makefile @@ -0,0 +1,6 @@ +CXX_SOURCES := main.cpp +CFLAGS := -g -O0 + +clean: OBJECTS+=$(wildcard main.d.*) + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/TestSTL.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/TestSTL.py new file mode 100644 index 00000000000..341b205389f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/TestSTL.py @@ -0,0 +1,122 @@ +""" +Test some expressions involving STL data types. +""" + + + +import unittest2 +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class STLTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.source = 'main.cpp' + self.line = line_number( + self.source, '// Set break point at this line.') + + @skipIf + @expectedFailureAll(bugnumber="llvm.org/PR36713") + def test(self): + """Test some expressions involving STL data types.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # The following two lines, if uncommented, will enable loggings. + #self.ci.HandleCommand("log enable -f /tmp/lldb.log lldb default", res) + # self.assertTrue(res.Succeeded()) + + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("run", RUN_SUCCEEDED) + + # Stop at 'std::string hello_world ("Hello World!");'. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['main.cpp:%d' % self.line, + 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) + + # Now try some expressions.... + + self.runCmd( + 'expr for (int i = 0; i < hello_world.length(); ++i) { (void)printf("%c\\n", hello_world[i]); }') + + self.expect('expr associative_array.size()', + substrs=[' = 3']) + self.expect('expr associative_array.count(hello_world)', + substrs=[' = 1']) + self.expect('expr associative_array[hello_world]', + substrs=[' = 1']) + self.expect('expr associative_array["hello"]', + substrs=[' = 2']) + + @expectedFailureAll( + compiler="icc", + bugnumber="ICC (13.1, 14-beta) do not emit DW_TAG_template_type_parameter.") + @add_test_categories(['pyapi']) + def test_SBType_template_aspects(self): + """Test APIs for getting template arguments from an SBType.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Create the breakpoint inside function 'main'. + breakpoint = target.BreakpointCreateByLocation(self.source, self.line) + self.assertTrue(breakpoint, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + # Get Frame #0. + self.assertTrue(process.GetState() == lldb.eStateStopped) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertTrue( + thread.IsValid(), + "There should be a thread stopped due to breakpoint condition") + frame0 = thread.GetFrameAtIndex(0) + + # Get the type for variable 'associative_array'. + associative_array = frame0.FindVariable('associative_array') + self.DebugSBValue(associative_array) + self.assertTrue(associative_array, VALID_VARIABLE) + map_type = associative_array.GetType() + self.DebugSBType(map_type) + self.assertTrue(map_type, VALID_TYPE) + num_template_args = map_type.GetNumberOfTemplateArguments() + self.assertTrue(num_template_args > 0) + + # We expect the template arguments to contain at least 'string' and + # 'int'. + expected_types = {'string': False, 'int': False} + for i in range(num_template_args): + t = map_type.GetTemplateArgumentType(i) + self.DebugSBType(t) + self.assertTrue(t, VALID_TYPE) + name = t.GetName() + if 'string' in name: + expected_types['string'] = True + elif 'int' == name: + expected_types['int'] = True + + # Check that both entries of the dictionary have 'True' as the value. + self.assertTrue(all(expected_types.values())) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py new file mode 100644 index 00000000000..49aa16ce106 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py @@ -0,0 +1,114 @@ +""" +Test the lldb disassemble command on lib stdc++. +""" + +from __future__ import print_function + + +import unittest2 +import os +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.decorators import * + +class StdCXXDisassembleTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.line = line_number('main.cpp', '// Set break point at this line.') + + @skipIfWindows + @expectedFailureNetBSD + def test_stdcxx_disasm(self): + """Do 'disassemble' on each and every 'Code' symbol entry from the std c++ lib.""" + self.build() + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # rdar://problem/8543077 + # test/stl: clang built binaries results in the breakpoint locations = 3, + # is this a problem with clang generated debug info? + # + # Break on line 13 of main.cpp. + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True) + + self.runCmd("run", RUN_SUCCEEDED) + + # Now let's get the target as well as the process objects. + target = self.dbg.GetSelectedTarget() + process = target.GetProcess() + + # The process should be in a 'stopped' state. + self.expect(str(process), STOPPED_DUE_TO_BREAKPOINT, exe=False, + substrs=["a.out", + "stopped"]) + + # Disassemble the functions on the call stack. + self.runCmd("thread backtrace") + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertIsNotNone(thread) + depth = thread.GetNumFrames() + for i in range(depth - 1): + frame = thread.GetFrameAtIndex(i) + function = frame.GetFunction() + if function.GetName(): + self.runCmd("disassemble -n '%s'" % function.GetName()) + + lib_stdcxx = "FAILHORRIBLYHERE" + # Iterate through the available modules, looking for stdc++ library... + for i in range(target.GetNumModules()): + module = target.GetModuleAtIndex(i) + fs = module.GetFileSpec() + if (fs.GetFilename().startswith("libstdc++") + or fs.GetFilename().startswith("libc++")): + lib_stdcxx = str(fs) + break + + # At this point, lib_stdcxx is the full path to the stdc++ library and + # module is the corresponding SBModule. + + self.expect(lib_stdcxx, "Libraray StdC++ is located", exe=False, + substrs=["lib"]) + + self.runCmd("image dump symtab '%s'" % lib_stdcxx) + raw_output = self.res.GetOutput() + # Now, look for every 'Code' symbol and feed its load address into the + # command: 'disassemble -s load_address -e end_address', where the + # end_address is taken from the next consecutive 'Code' symbol entry's + # load address. + # + # The load address column comes after the file address column, with both + # looks like '0xhhhhhhhh', i.e., 8 hexadecimal digits. + codeRE = re.compile(r""" + \ Code\ {9} # ' Code' followed by 9 SPCs, + 0x[0-9a-f]{16} # the file address column, and + \ # a SPC, and + (0x[0-9a-f]{16}) # the load address column, and + .* # the rest. + """, re.VERBOSE) + # Maintain a start address variable; if we arrive at a consecutive Code + # entry, then the load address of the that entry is fed as the end + # address to the 'disassemble -s SA -e LA' command. + SA = None + for line in raw_output.split(os.linesep): + match = codeRE.search(line) + if match: + LA = match.group(1) + if self.TraceOn(): + print("line:", line) + print("load address:", LA) + print("SA:", SA) + if SA and LA: + if int(LA, 16) > int(SA, 16): + self.runCmd("disassemble -s %s -e %s" % (SA, LA)) + SA = LA + else: + # This entry is not a Code entry. Reset SA = None. + SA = None diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/cmds.txt b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/cmds.txt new file mode 100644 index 00000000000..9c9c2e3db57 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/cmds.txt @@ -0,0 +1,3 @@ +b main.cpp:6 +continue +var diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/main.cpp new file mode 100644 index 00000000000..89895196b15 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/stl/main.cpp @@ -0,0 +1,29 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include <cstdio> +#include <iostream> +#include <string> +#include <map> +int main (int argc, char const *argv[]) +{ + std::string hello_world ("Hello World!"); + std::cout << hello_world << std::endl; + std::cout << hello_world.length() << std::endl; + std::cout << hello_world[11] << std::endl; + + std::map<std::string, int> associative_array; + std::cout << "size of upon construction associative_array: " << associative_array.size() << std::endl; + associative_array[hello_world] = 1; + associative_array["hello"] = 2; + associative_array["world"] = 3; + + std::cout << "size of associative_array: " << associative_array.size() << std::endl; + printf("associative_array[\"hello\"]=%d\n", associative_array["hello"]); + + printf("before returning....\n"); // Set break point at this line. +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/symbols/TestSymbols.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/symbols/TestSymbols.py new file mode 100644 index 00000000000..af362f5be5d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/symbols/TestSymbols.py @@ -0,0 +1,7 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest( + __file__, globals(), [ + decorators.expectedFailureAll( + oslist=["windows"], bugnumber="llvm.org/pr24764")]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/symbols/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/symbols/main.cpp new file mode 100644 index 00000000000..cbd3ab253d6 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/symbols/main.cpp @@ -0,0 +1,39 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +void *D = 0; + +class D { + static int i; +}; + +int D::i = 3; + +namespace errno { + int j = 4; +}; + +int twice(int n) +{ + return n * 2; //% self.expect("expression -- D::i", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["int", "3"]) + //% self.expect("expression -- D", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["void"]) + //% self.expect("expression -- errno::j", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["int", "4"]) +} + +const char getAChar() +{ + const char D[] = "Hello world"; + return D[0]; //% self.expect("expression -- D::i", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["int", "3"]) + //% self.expect("expression -- D", DATA_TYPES_DISPLAYED_CORRECTLY, substrs = ["char", "Hello"]) +} + +int main (int argc, char const *argv[]) +{ + int six = twice(3); + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/TestTemplateFunctions.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/TestTemplateFunctions.py new file mode 100644 index 00000000000..6c9a0ac35f4 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/TestTemplateFunctions.py @@ -0,0 +1,32 @@ +""" +Test that we can call C++ template fucntions. +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TemplateFunctionsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def do_test_template_function(self, add_cast): + self.build() + (_, _, thread, _) = lldbutil.run_to_name_breakpoint(self, "main") + frame = thread.GetSelectedFrame() + expr = "foo(42)" + if add_cast: + expr = "(int)" + expr + expr_result = frame.EvaluateExpression(expr) + self.assertTrue(expr_result.IsValid()) + self.assertEqual(expr_result.GetValue(), "42") + + @skipIfWindows + def test_template_function_with_cast(self): + self.do_test_template_function(True) + + @skipIfWindows + @expectedFailureAll(debug_info=["dwarf", "gmodules", "dwo"]) + def test_template_function_without_cast(self): + self.do_test_template_function(False) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/main.cpp new file mode 100644 index 00000000000..035e6450cd3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template-function/main.cpp @@ -0,0 +1,16 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +template<typename T> +int foo(T t1) { + return int(t1); +} + +int main() { + return foo(42); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/TestTemplateArgs.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/TestTemplateArgs.py new file mode 100644 index 00000000000..08132702b8d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/TestTemplateArgs.py @@ -0,0 +1,158 @@ +""" +Test that C++ template classes that have integer parameters work correctly. + +We must reconstruct the types correctly so the template types are correct +and display correctly, and also make sure the expression parser works and +is able the find all needed functions when evaluating expressions +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TemplateArgsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def prepareProcess(self): + self.build() + + # Create a target by the debugger. + exe = self.getBuildArtifact("a.out") + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Set breakpoints inside and outside methods that take pointers to the + # containing struct. + line = line_number('main.cpp', '// Breakpoint 1') + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=1, loc_exact=True) + + arguments = None + environment = None + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + arguments, environment, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + # Get the thread of the process + self.assertTrue( + process.GetState() == lldb.eStateStopped, + PROCESS_STOPPED) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + + # Get frame for current thread + return thread.GetSelectedFrame() + + def test_integer_args(self): + frame = self.prepareProcess() + + testpos = frame.FindVariable('testpos') + self.assertTrue( + testpos.IsValid(), + 'make sure we find a local variabble named "testpos"') + self.assertTrue(testpos.GetType().GetName() == 'TestObj<1>') + + expr_result = frame.EvaluateExpression("testpos.getArg()") + self.assertTrue( + expr_result.IsValid(), + 'got a valid expression result from expression "testpos.getArg()"') + self.assertTrue(expr_result.GetValue() == "1", "testpos.getArg() == 1") + self.assertTrue( + expr_result.GetType().GetName() == "int", + 'expr_result.GetType().GetName() == "int"') + + testneg = frame.FindVariable('testneg') + self.assertTrue( + testneg.IsValid(), + 'make sure we find a local variabble named "testneg"') + self.assertTrue(testneg.GetType().GetName() == 'TestObj<-1>') + + expr_result = frame.EvaluateExpression("testneg.getArg()") + self.assertTrue( + expr_result.IsValid(), + 'got a valid expression result from expression "testneg.getArg()"') + self.assertTrue( + expr_result.GetValue() == "-1", + "testneg.getArg() == -1") + self.assertTrue( + expr_result.GetType().GetName() == "int", + 'expr_result.GetType().GetName() == "int"') + + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24489") + def test_template_template_args(self): + frame = self.prepareProcess() + + c1 = frame.FindVariable('c1') + self.assertTrue( + c1.IsValid(), + 'make sure we find a local variabble named "c1"') + self.assertTrue(c1.GetType().GetName() == 'C<float, T1>') + f1 = c1.GetChildMemberWithName("V").GetChildAtIndex(0).GetChildMemberWithName("f") + self.assertTrue(f1.GetType().GetName() == 'float') + self.assertTrue(f1.GetValue() == '1.5') + + c2 = frame.FindVariable('c2') + self.assertTrue( + c2.IsValid(), + 'make sure we find a local variabble named "c2"') + self.assertTrue(c2.GetType().GetName() == 'C<double, T1, T2>') + f2 = c2.GetChildMemberWithName("V").GetChildAtIndex(0).GetChildMemberWithName("f") + self.assertTrue(f2.GetType().GetName() == 'double') + self.assertTrue(f2.GetValue() == '1.5') + f3 = c2.GetChildMemberWithName("V").GetChildAtIndex(1).GetChildMemberWithName("f") + self.assertTrue(f3.GetType().GetName() == 'double') + self.assertTrue(f3.GetValue() == '2.5') + f4 = c2.GetChildMemberWithName("V").GetChildAtIndex(1).GetChildMemberWithName("i") + self.assertTrue(f4.GetType().GetName() == 'int') + self.assertTrue(f4.GetValue() == '42') + + # Gcc does not generate the necessary DWARF attribute for enum template + # parameters. + @expectedFailureAll(bugnumber="llvm.org/pr28354", compiler="gcc") + @skipIf(dwarf_version=['<', '4']) + def test_enum_args(self): + frame = self.prepareProcess() + + # Make sure "member" can be displayed and also used in an expression + # correctly + member = frame.FindVariable('member') + self.assertTrue( + member.IsValid(), + 'make sure we find a local variabble named "member"') + self.assertTrue(member.GetType().GetName() == + 'EnumTemplate<EnumType::Member>') + + expr_result = frame.EvaluateExpression("member.getMember()") + self.assertTrue( + expr_result.IsValid(), + 'got a valid expression result from expression "member.getMember()"') + self.assertTrue( + expr_result.GetValue() == "123", + "member.getMember() == 123") + self.assertTrue( + expr_result.GetType().GetName() == "int", + 'expr_result.GetType().GetName() == "int"') + + # Make sure "subclass" can be displayed and also used in an expression + # correctly + subclass = frame.FindVariable('subclass') + self.assertTrue( + subclass.IsValid(), + 'make sure we find a local variabble named "subclass"') + self.assertTrue(subclass.GetType().GetName() == + 'EnumTemplate<EnumType::Subclass>') + + expr_result = frame.EvaluateExpression("subclass.getMember()") + self.assertTrue( + expr_result.IsValid(), + 'got a valid expression result from expression "subclass.getMember()"') + self.assertTrue( + expr_result.GetValue() == "246", + "subclass.getMember() == 246") + self.assertTrue( + expr_result.GetType().GetName() == "int", + 'expr_result.GetType().GetName() == "int"') diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/main.cpp new file mode 100644 index 00000000000..445a34fe067 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/template/main.cpp @@ -0,0 +1,78 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include <tuple> + +template <int Arg> +class TestObj +{ +public: + int getArg() + { + return Arg; + } +}; + +//---------------------------------------------------------------------- +// Define a template class that we can specialize with an enumeration +//---------------------------------------------------------------------- +enum class EnumType +{ + Member, + Subclass +}; + +template <EnumType Arg> class EnumTemplate; + +//---------------------------------------------------------------------- +// Specialization for use when "Arg" is "EnumType::Member" +//---------------------------------------------------------------------- +template <> +class EnumTemplate<EnumType::Member> +{ +public: + EnumTemplate(int m) : + m_member(m) + { + } + + int getMember() const + { + return m_member; + } + +protected: + int m_member; +}; + +//---------------------------------------------------------------------- +// Specialization for use when "Arg" is "EnumType::Subclass" +//---------------------------------------------------------------------- +template <> +class EnumTemplate<EnumType::Subclass> : + public EnumTemplate<EnumType::Member> +{ +public: + EnumTemplate(int m) : EnumTemplate<EnumType::Member>(m) + { + } +}; + +template <typename FLOAT> struct T1 { FLOAT f = 1.5; }; +template <typename FLOAT> struct T2 { FLOAT f = 2.5; int i = 42; }; +template <typename FLOAT, template <typename> class ...Args> class C { std::tuple<Args<FLOAT>...> V; }; + +int main(int argc, char **argv) +{ + TestObj<1> testpos; + TestObj<-1> testneg; + EnumTemplate<EnumType::Member> member(123); + EnumTemplate<EnumType::Subclass> subclass(123*2); + C<float, T1> c1; + C<double, T1, T2> c2; + return testpos.getArg() - testneg.getArg() + member.getMember()*2 - subclass.getMember(); // Breakpoint 1 +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py new file mode 100644 index 00000000000..ab95627729d --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py @@ -0,0 +1,61 @@ +""" +Tests that C++ member and static variables are available where they should be. +""" +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class CPPThisTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + # rdar://problem/9962849 + @expectedFailureAll( + compiler="gcc", + bugnumber="llvm.org/pr15439 The 'this' pointer isn't available during expression evaluation when stopped in an inlined member function") + @expectedFailureAll( + compiler="icc", + bugnumber="ICC doesn't emit correct DWARF inline debug info for inlined member functions.") + @expectedFailureAll( + oslist=["windows"], + bugnumber="llvm.org/pr24489: Name lookup not working correctly on Windows") + @expectedFailureNetBSD + def test_with_run_command(self): + """Test that the appropriate member variables are available when stopped in C++ static, inline, and const methods""" + self.build() + self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET) + + self.set_breakpoint(line_number('main.cpp', '// breakpoint 1')) + self.set_breakpoint(line_number('main.cpp', '// breakpoint 2')) + self.set_breakpoint(line_number('main.cpp', '// breakpoint 3')) + self.set_breakpoint(line_number('main.cpp', '// breakpoint 4')) + + self.runCmd("process launch", RUN_SUCCEEDED) + + self.expect("expression -- m_a = 2", + startstr="(int) $0 = 2") + + self.runCmd("process continue") + + # This would be disallowed if we enforced const. But we don't. + self.expect("expression -- m_a = 2", + startstr="(int) $1 = 2") + + self.expect("expression -- (int)getpid(); m_a", + startstr="(int) $2 = 2") + + self.runCmd("process continue") + + self.expect("expression -- s_a", + startstr="(int) $3 = 5") + + self.runCmd("process continue") + + self.expect("expression -- m_a", + startstr="(int) $4 = 2") + + def set_breakpoint(self, line): + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", line, num_expected_locations=1, loc_exact=False) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/main.cpp new file mode 100644 index 00000000000..4026de0222f --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/this/main.cpp @@ -0,0 +1,52 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +template <class T> class A +{ +public: + void accessMember(T a); + T accessMemberConst() const; + static int accessStaticMember(); + + void accessMemberInline(T a) __attribute__ ((always_inline)) + { + m_a = a; // breakpoint 4 + } + + T m_a; + static int s_a; +}; + +template <class T> int A<T>::s_a = 5; + +template <class T> void A<T>::accessMember(T a) +{ + m_a = a; // breakpoint 1 +} + +template <class T> T A<T>::accessMemberConst() const +{ + return m_a; // breakpoint 2 +} + +template <class T> int A<T>::accessStaticMember() +{ + return s_a; // breakpoint 3 +} + +int main() +{ + A<int> my_a; + + my_a.accessMember(3); + my_a.accessMemberConst(); + A<int>::accessStaticMember(); + my_a.accessMemberInline(5); +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/Makefile new file mode 100644 index 00000000000..3d0b98f13f3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/Makefile @@ -0,0 +1,2 @@ +CXX_SOURCES := main.cpp +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/TestThreadLocal.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/TestThreadLocal.py new file mode 100644 index 00000000000..5152c0010d1 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/TestThreadLocal.py @@ -0,0 +1,6 @@ +from lldbsuite.test import lldbinline +from lldbsuite.test import decorators + +lldbinline.MakeInlineTest(__file__, globals(), + lldbinline.expectedFailureAll(oslist=[ + "windows", "linux", "netbsd"])) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/main.cpp new file mode 100644 index 00000000000..1855b7c5f34 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/thread_local/main.cpp @@ -0,0 +1,17 @@ +int storage = 45; +thread_local int tl_global_int = 123; +thread_local int *tl_global_ptr = &storage; + +int main(int argc, char **argv) { + //% self.expect("expr tl_local_int", error=True, substrs=["couldn't get the value of variable tl_local_int"]) + //% self.expect("expr *tl_local_ptr", error=True, substrs=["couldn't get the value of variable tl_local_ptr"]) + thread_local int tl_local_int = 321; + thread_local int *tl_local_ptr = nullptr; + tl_local_ptr = &tl_local_int; + tl_local_int++; + //% self.expect("expr tl_local_int + 1", substrs=["int", "= 323"]) + //% self.expect("expr *tl_local_ptr + 2", substrs=["int", "= 324"]) + //% self.expect("expr tl_global_int", substrs=["int", "= 123"]) + //% self.expect("expr *tl_global_ptr", substrs=["int", "= 45"]) + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/TestTrivialABI.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/TestTrivialABI.py new file mode 100644 index 00000000000..2a8a78a45ff --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/TestTrivialABI.py @@ -0,0 +1,72 @@ +""" +Test that we work properly with classes with the trivial_abi attribute +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +class TestTrivialABI(TestBase): + + mydir = TestBase.compute_mydir(__file__) + NO_DEBUG_INFO_TESTCASE = True + + @skipUnlessSupportedTypeAttribute("trivial_abi") + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr37995") + @expectedFailureAll(archs=["aarch64"], oslist=["linux"], + bugnumber="llvm.org/pr44161") + def test_call_trivial(self): + """Test that we can print a variable & call a function with a trivial ABI class.""" + self.build() + self.main_source_file = lldb.SBFileSpec("main.cpp") + self.expr_test(True) + + @skipUnlessSupportedTypeAttribute("trivial_abi") + # fixed for SysV-x86_64 ABI, but not Windows-x86_64 + @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr36870") + @expectedFailureAll(archs=["aarch64"], oslist=["linux"], + bugnumber="llvm.org/pr44161") + @expectedFailureAll(archs=["arm64", "arm64e"], bugnumber="<rdar://problem/57844240>") + def test_call_nontrivial(self): + """Test that we can print a variable & call a function on the same class w/o the trivial ABI marker.""" + self.build() + self.main_source_file = lldb.SBFileSpec("main.cpp") + self.expr_test(False) + + def check_value(self, test_var, ivar_value): + self.assertTrue(test_var.GetError().Success(), "Invalid valobj: %s"%(test_var.GetError().GetCString())) + ivar = test_var.GetChildMemberWithName("ivar") + self.assertTrue(test_var.GetError().Success(), "Failed to fetch ivar") + self.assertEqual(ivar_value, ivar.GetValueAsSigned(), "Got the right value for ivar") + + def check_frame(self, thread): + frame = thread.frames[0] + inVal_var = frame.FindVariable("inVal") + self.check_value(inVal_var, 10) + + options = lldb.SBExpressionOptions() + inVal_expr = frame.EvaluateExpression("inVal", options) + self.check_value(inVal_expr, 10) + + thread.StepOut() + outVal_ret = thread.GetStopReturnValue() + self.check_value(outVal_ret, 30) + + def expr_test(self, trivial): + (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self, + "Set a breakpoint here", self.main_source_file) + + # Stop in a function that takes a trivial value, and try both frame var & expr to get its value: + if trivial: + self.check_frame(thread) + return + + # Now continue to the same thing without the trivial_abi and see if we get that right: + threads = lldbutil.continue_to_breakpoint(process, bkpt) + self.assertEqual(len(threads), 1, "Hit my breakpoint the second time.") + + self.check_frame(threads[0]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/main.cpp new file mode 100644 index 00000000000..b1f50159692 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/trivial_abi/main.cpp @@ -0,0 +1,35 @@ +struct __attribute__((trivial_abi)) S_Trivial { + ~S_Trivial() {} + int ivar = 10; +}; + +S_Trivial takeTrivial(S_Trivial inVal) +{ + S_Trivial ret_val = inVal; + ret_val.ivar = 30; + return ret_val; // Set a breakpoint here +} + +struct S_NotTrivial { + ~S_NotTrivial() {} + int ivar = 10; +}; + +S_NotTrivial takeNotTrivial(S_NotTrivial inVal) +{ + S_NotTrivial ret_val = inVal; + ret_val.ivar = 30; + return ret_val; // Set a breakpoint here +} + +int +main() +{ + S_Trivial inVal, outVal; + outVal = takeTrivial(inVal); + + S_NotTrivial inNotVal, outNotVal; + outNotVal = takeNotTrivial(inNotVal); + + return 0; // Set another for return value +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/Makefile new file mode 100644 index 00000000000..3d0b98f13f3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/Makefile @@ -0,0 +1,2 @@ +CXX_SOURCES := main.cpp +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/TestCppTypeLookup.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/TestCppTypeLookup.py new file mode 100644 index 00000000000..45be73118f8 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/TestCppTypeLookup.py @@ -0,0 +1,93 @@ +""" +Test that we can lookup types correctly in the expression parser +""" + + + +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * +from lldbsuite.test import decorators + +class TestCppTypeLookup(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def check_value(self, value, ivar_name, ivar_value): + self.assertTrue(value.GetError().Success(), + "Invalid valobj: %s" % ( + value.GetError().GetCString())) + ivar = value.GetChildMemberWithName(ivar_name) + self.assertTrue(ivar.GetError().Success(), + "Failed to fetch ivar named '%s'" % (ivar_name)) + self.assertEqual(ivar_value, + ivar.GetValueAsSigned(), + "Got the right value for ivar") + + def test_namespace_only(self): + """ + Test that we fail to lookup a struct type that exists only in a + namespace. + """ + self.build() + self.main_source_file = lldb.SBFileSpec("main.cpp") + (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint( + self, "Set a breakpoint here", self.main_source_file) + + # Get frame for current thread + frame = thread.GetSelectedFrame() + + # We are testing LLDB's type lookup machinery, but if we inject local + # variables, the types for those will be found because they have been + # imported through the variable, not because the type lookup worked. + self.runCmd("settings set target.experimental.inject-local-vars false") + + # Make sure we don't accidentally accept structures that exist only + # in namespaces when evaluating expressions with top level types. + # Prior to the revision that added this test, we would accidentally + # accept types from namespaces, so this will ensure we don't regress + # to that behavior again + expr_result = frame.EvaluateExpression("*((namespace_only *)&i)") + self.assertTrue(expr_result.GetError().Fail(), + "'namespace_only' exists in namespace only") + + # Make sure we can find the correct type in a namespace "nsp_a" + expr_result = frame.EvaluateExpression("*((nsp_a::namespace_only *)&i)") + self.check_value(expr_result, "a", 123) + # Make sure we can find the correct type in a namespace "nsp_b" + expr_result = frame.EvaluateExpression("*((nsp_b::namespace_only *)&i)") + self.check_value(expr_result, "b", 123) + + # Make sure we can find the correct type in the root namespace + expr_result = frame.EvaluateExpression("*((namespace_and_file *)&i)") + self.check_value(expr_result, "ff", 123) + # Make sure we can find the correct type in a namespace "nsp_a" + expr_result = frame.EvaluateExpression( + "*((nsp_a::namespace_and_file *)&i)") + self.check_value(expr_result, "aa", 123) + # Make sure we can find the correct type in a namespace "nsp_b" + expr_result = frame.EvaluateExpression( + "*((nsp_b::namespace_and_file *)&i)") + self.check_value(expr_result, "bb", 123) + + # Make sure we don't accidentally accept structures that exist only + # in namespaces when evaluating expressions with top level types. + # Prior to the revision that added this test, we would accidentally + # accept types from namespaces, so this will ensure we don't regress + # to that behavior again + expr_result = frame.EvaluateExpression("*((in_contains_type *)&i)") + self.assertTrue(expr_result.GetError().Fail(), + "'in_contains_type' exists in struct only") + + # Make sure we can find the correct type in the root namespace + expr_result = frame.EvaluateExpression( + "*((contains_type::in_contains_type *)&i)") + self.check_value(expr_result, "fff", 123) + # Make sure we can find the correct type in a namespace "nsp_a" + expr_result = frame.EvaluateExpression( + "*((nsp_a::contains_type::in_contains_type *)&i)") + self.check_value(expr_result, "aaa", 123) + # Make sure we can find the correct type in a namespace "nsp_b" + expr_result = frame.EvaluateExpression( + "*((nsp_b::contains_type::in_contains_type *)&i)") + self.check_value(expr_result, "bbb", 123) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/main.cpp new file mode 100644 index 00000000000..f2803e36152 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/type_lookup/main.cpp @@ -0,0 +1,66 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// In this test, we define struct that exist might exist at the different +// levels in the code and test that we can properly locate these types with +// a varienty of different expressions. + +namespace nsp_a { + struct namespace_only { + int a; + }; + struct namespace_and_file { + int aa; + }; + struct contains_type { + struct in_contains_type { + int aaa; + }; + }; +}; +namespace nsp_b { + struct namespace_only { + int b; + }; + struct namespace_and_file { + int bb; + }; + struct contains_type { + struct in_contains_type { + int bbb; + }; + }; +}; + +struct namespace_and_file { + int ff; +}; + +struct contains_type { + struct in_contains_type { + int fff; + }; +}; + + +int main (int argc, char const *argv[]) { + nsp_a::namespace_only a_namespace_only = { 1 }; + nsp_a::namespace_and_file a_namespace_and_file = { 2 }; + nsp_a::contains_type::in_contains_type a_in_contains_type = { 3 }; + nsp_b::namespace_only b_namespace_only = { 11 }; + nsp_b::namespace_and_file b_namespace_and_file = { 22 }; + nsp_b::contains_type::in_contains_type b_in_contains_type = { 33 }; + namespace_and_file file_namespace_and_file = { 44 }; + contains_type::in_contains_type file_in_contains_type = { 55 }; + int i = 123; // Provide an integer that can be used for casting + // Take address of "i" to ensure it is in memory + if (&i == &argc) { + i = -1; + } + return i == -1; // Set a breakpoint here +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/Makefile new file mode 100644 index 00000000000..bf443d855ce --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/Makefile @@ -0,0 +1,6 @@ +CXX_SOURCES := main.cpp +CFLAGS := -g -O0 -std=c++11 + +clean: OBJECTS+=$(wildcard main.d.*) + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/TestUnicodeLiterals.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/TestUnicodeLiterals.py new file mode 100644 index 00000000000..c1bd892447a --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/TestUnicodeLiterals.py @@ -0,0 +1,83 @@ +# coding=utf8 +""" +Test that the expression parser returns proper Unicode strings. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + +# this test case fails because of rdar://12991846 +# the expression parser does not deal correctly with Unicode expressions +# e.g. +#(lldb) expr L"Hello" +#(const wchar_t [6]) $0 = { +# [0] = \0\0\0\0 +# [1] = \0\0\0\0 +# [2] = \0\0\0\0 +# [3] = \0\0\0\0 +# [4] = H\0\0\0 +# [5] = e\0\0\0 +#} + + +class UnicodeLiteralsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_expr1(self): + """Test that the expression parser returns proper Unicode strings.""" + self.build() + self.rdar12991846(expr=1) + + def test_expr2(self): + """Test that the expression parser returns proper Unicode strings.""" + self.build() + self.rdar12991846(expr=2) + + def test_expr3(self): + """Test that the expression parser returns proper Unicode strings.""" + self.build() + self.rdar12991846(expr=3) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break for main.cpp. + self.source = 'main.cpp' + self.line = line_number( + self.source, '// Set break point at this line.') + + def rdar12991846(self, expr=None): + """Test that the expression parser returns proper Unicode strings.""" + if self.getArchitecture() in ['i386']: + self.skipTest( + "Skipping because this test is known to crash on i386") + + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Break on the struct declration statement in main.cpp. + lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + if not process: + self.fail("SBTarget.Launch() failed") + + if expr == 1: + self.expect('expression L"hello"', substrs=['hello']) + + if expr == 2: + self.expect('expression u"hello"', substrs=['hello']) + + if expr == 3: + self.expect('expression U"hello"', substrs=['hello']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/main.cpp new file mode 100644 index 00000000000..a98fb44e5f4 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unicode-literals/main.cpp @@ -0,0 +1,20 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + + +int main (int argc, char const *argv[]) +{ + auto cs16 = u"hello world ྒྙྐ"; + auto cs32 = U"hello world ྒྙྐ"; + char16_t *s16 = (char16_t *)u"ﺸﺵۻ"; + char32_t *s32 = (char32_t *)U"ЕЙРГЖО"; + s32 = nullptr; // Set break point at this line. + s32 = (char32_t *)U"෴"; + s16 = (char16_t *)u"色ハ匂ヘト散リヌルヲ"; + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/TestUniqueTypes.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/TestUniqueTypes.py new file mode 100644 index 00000000000..78121c14970 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/TestUniqueTypes.py @@ -0,0 +1,65 @@ +""" +Test that template instaniations of std::vector<long> and <short> in the same module have the correct types. +""" + + + +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + + +class UniqueTypesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number inside main.cpp. + self.line = line_number( + "main.cpp", + "// Set breakpoint here to verify that std::vector 'longs' and 'shorts' have unique types.") + + def test(self): + """Test for unique types of std::vector<long> and std::vector<short>.""" + self.build() + + compiler = self.getCompiler() + compiler_basename = os.path.basename(compiler) + + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + lldbutil.run_break_set_by_file_and_line( + self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True) + + self.runCmd("run", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', + 'stop reason = breakpoint']) + + # Do a "frame variable --show-types longs" and verify "long" is in each + # line of output. + self.runCmd("frame variable --show-types longs") + output = self.res.GetOutput() + for x in [line.strip() for line in output.split(os.linesep)]: + # Skip empty line, closing brace, and messages about more variables + # than can be displayed. + if not x or x == '}' or x == '...' or "Some of your variables have more members than the debugger will show by default" in x: + continue + self.expect(x, "Expect type 'long'", exe=False, + substrs=['long']) + + # Do a "frame variable --show-types shorts" and verify "short" is in + # each line of output. + self.runCmd("frame variable --show-types shorts") + output = self.res.GetOutput() + for x in [line.strip() for line in output.split(os.linesep)]: + # Skip empty line, closing brace, and messages about more variables + # than can be displayed. + if not x or x == '}' or x == '...' or "Some of your variables have more members than the debugger will show by default" in x: + continue + self.expect(x, "Expect type 'short'", exe=False, + substrs=['short']) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/main.cpp new file mode 100644 index 00000000000..839fd93f764 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unique-types/main.cpp @@ -0,0 +1,23 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +#include <vector> + +#include <stdio.h> +#include <stdint.h> + +int main (int argc, char const *argv[], char const *envp[]) +{ + std::vector<long> longs; + std::vector<short> shorts; + for (int i=0; i<12; i++) + { + longs.push_back(i); + shorts.push_back(i); + } + return 0; // Set breakpoint here to verify that std::vector 'longs' and 'shorts' have unique types. +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py new file mode 100644 index 00000000000..ca754f470da --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py @@ -0,0 +1,60 @@ +""" +Test that variables with unsigned types display correctly. +""" + + + +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class UnsignedTypesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break inside main(). + self.line = line_number('main.cpp', '// Set break point at this line.') + + def test(self): + """Test that variables with unsigned types display correctly.""" + self.build() + exe = self.getBuildArtifact("a.out") + self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET) + + # GCC puts a breakpoint on the last line of a multi-line expression, so + # if GCC is the target compiler, we cannot rely on an exact line match. + need_exact = "gcc" not in self.getCompiler() + # Break on line 19 in main() after the variables are assigned values. + lldbutil.run_break_set_by_file_and_line( + self, + "main.cpp", + self.line, + num_expected_locations=-1, + loc_exact=need_exact) + + self.runCmd("run", RUN_SUCCEEDED) + + # The stop reason of the thread should be breakpoint. + self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT, + substrs=['stopped', 'stop reason = breakpoint']) + + # The breakpoint should have a hit count of 1. + self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE, + substrs=[' resolved, hit count = 1']) + + # Test that unsigned types display correctly. + self.expect( + "frame variable --show-types --no-args", + VARIABLES_DISPLAYED_CORRECTLY, + patterns=["\((short unsigned int|unsigned short)\) the_unsigned_short = 99"], + substrs=[ + "(unsigned char) the_unsigned_char = 'c'", + "(unsigned int) the_unsigned_int = 99", + "(unsigned long) the_unsigned_long = 99", + "(unsigned long long) the_unsigned_long_long = 99", + "(uint32_t) the_uint32 = 99"]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/main.cpp new file mode 100644 index 00000000000..8d0a0c386e3 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/main.cpp @@ -0,0 +1,21 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +int main (int argc, char const *argv[]) +{ + typedef unsigned int uint32_t; + unsigned char the_unsigned_char = 'c'; + unsigned short the_unsigned_short = 'c'; + unsigned int the_unsigned_int = 'c'; + unsigned long the_unsigned_long = 'c'; + unsigned long long the_unsigned_long_long = 'c'; + uint32_t the_uint32 = 'c'; + + return the_unsigned_char - the_unsigned_short + // Set break point at this line. + the_unsigned_int - the_unsigned_long + + the_unsigned_long_long - the_uint32; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual-overload/TestVirtualOverload.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual-overload/TestVirtualOverload.py new file mode 100644 index 00000000000..1311a149326 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual-overload/TestVirtualOverload.py @@ -0,0 +1,3 @@ +from lldbsuite.test import lldbinline + +lldbinline.MakeInlineTest(__file__, globals()) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual-overload/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual-overload/main.cpp new file mode 100644 index 00000000000..79c482352f9 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual-overload/main.cpp @@ -0,0 +1,17 @@ +// Test that lldb doesn't get confused by an overload of a virtual +// function of the same name. +struct Base { + virtual void f(int i) {} + virtual ~Base() {} +}; + +struct Derived : Base { + virtual void f(int i, int j) {} +}; + +int main(int argc, char **argv) { + Derived obj; + obj.f(1, 2); //% self.expect("fr var", "not crashing", substrs = ["obj"]) + return 0; +} + diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/Makefile new file mode 100644 index 00000000000..99998b20bcb --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/Makefile @@ -0,0 +1,3 @@ +CXX_SOURCES := main.cpp + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py new file mode 100644 index 00000000000..22fe96b96d2 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py @@ -0,0 +1,101 @@ +""" +Test C++ virtual function and virtual inheritance. +""" + +import os +import re +import lldb +from lldbsuite.test.decorators import * +from lldbsuite.test.lldbtest import * +from lldbsuite.test import lldbutil + + +def Msg(expr, val): + return "'expression %s' matches the output (from compiled code): %s" % ( + expr, val) + + +class CppVirtualMadness(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + # This is the pattern by design to match the "my_expr = 'value'" output from + # printf() stmts (see main.cpp). + pattern = re.compile("^([^=]*) = '([^=]*)'$") + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break for main.cpp. + self.source = 'main.cpp' + self.line = line_number(self.source, '// Set first breakpoint here.') + + @expectedFailureAll( + compiler="icc", + bugnumber="llvm.org/pr16808 lldb does not call the correct virtual function with icc.") + @skipIfWindows # This test will hang on windows llvm.org/pr21753 + @expectedFlakeyNetBSD + def test_virtual_madness(self): + """Test that expression works correctly with virtual inheritance as well as virtual function.""" + self.build() + + # Bring the program to the point where we can issue a series of + # 'expression' command to compare against the golden output. + self.dbg.SetAsync(False) + + # Create a target by the debugger. + target = self.dbg.CreateTarget(self.getBuildArtifact("a.out")) + self.assertTrue(target, VALID_TARGET) + + # Create the breakpoint inside function 'main'. + breakpoint = target.BreakpointCreateByLocation(self.source, self.line) + self.assertTrue(breakpoint, VALID_BREAKPOINT) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + self.assertTrue(process, PROCESS_IS_VALID) + + self.assertTrue(process.GetState() == lldb.eStateStopped) + thread = lldbutil.get_stopped_thread( + process, lldb.eStopReasonBreakpoint) + self.assertTrue( + thread.IsValid(), + "There should be a thread stopped due to breakpoint condition") + + # First, capture the golden output from the program itself. + golden = thread.GetFrameAtIndex(0).FindVariable("golden") + self.assertTrue( + golden.IsValid(), + "Encountered an error reading the process's golden variable") + error = lldb.SBError() + golden_str = process.ReadCStringFromMemory( + golden.AddressOf().GetValueAsUnsigned(), 4096, error) + self.assertTrue(error.Success()) + self.assertTrue("c_as_C" in golden_str) + + # This golden list contains a list of "my_expr = 'value' pairs extracted + # from the golden output. + gl = [] + + # Scan the golden output line by line, looking for the pattern: + # + # my_expr = 'value' + # + for line in golden_str.split(os.linesep): + match = self.pattern.search(line) + if match: + my_expr, val = match.group(1), match.group(2) + gl.append((my_expr, val)) + #print("golden list:", gl) + + # Now iterate through the golden list, comparing against the output from + # 'expression var'. + for my_expr, val in gl: + + self.runCmd("expression %s" % my_expr) + output = self.res.GetOutput() + + # The expression output must match the oracle. + self.expect(output, Msg(my_expr, val), exe=False, + substrs=[val]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/main.cpp new file mode 100644 index 00000000000..0adf4157731 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/virtual/main.cpp @@ -0,0 +1,116 @@ +#include <stdio.h> +#include <stdint.h> + +class A +{ +public: + A () : m_pad ('c') {} + + virtual ~A () {} + + virtual const char * a() + { + return __PRETTY_FUNCTION__; + } + + virtual const char * b() + { + return __PRETTY_FUNCTION__; + } + + virtual const char * c() + { + return __PRETTY_FUNCTION__; + } +protected: + char m_pad; +}; + +class AA +{ +public: + AA () : m_pad('A') {} + virtual ~AA () {} + + virtual const char * aa() + { + return __PRETTY_FUNCTION__; + } + +protected: + char m_pad; +}; + +class B : virtual public A, public AA +{ +public: + B () : m_pad ('c') {} + + virtual ~B () {} + + virtual const char * a() + { + return __PRETTY_FUNCTION__; + } + + virtual const char * b() + { + return __PRETTY_FUNCTION__; + } +protected: + char m_pad; +}; + +class C : public B, virtual public A +{ +public: + C () : m_pad ('c') {} + + virtual ~C () {} + + virtual const char * a() + { + return __PRETTY_FUNCTION__; + } +protected: + char m_pad; +}; + +int main (int argc, char const *argv[], char const *envp[]) +{ + A *a_as_A = new A(); + B *b_as_B = new B(); + A *b_as_A = b_as_B; + C *c_as_C = new C(); + A *c_as_A = c_as_C; + + char golden[4096]; + char *p = golden; + char *end = p + sizeof golden; + p += snprintf(p, end-p, "a_as_A->a() = '%s'\n", a_as_A->a()); + p += snprintf(p, end-p, "a_as_A->b() = '%s'\n", a_as_A->b()); + p += snprintf(p, end-p, "a_as_A->c() = '%s'\n", a_as_A->c()); + p += snprintf(p, end-p, "b_as_A->a() = '%s'\n", b_as_A->a()); + p += snprintf(p, end-p, "b_as_A->b() = '%s'\n", b_as_A->b()); + p += snprintf(p, end-p, "b_as_A->c() = '%s'\n", b_as_A->c()); + p += snprintf(p, end-p, "b_as_B->aa() = '%s'\n", b_as_B->aa()); + p += snprintf(p, end-p, "c_as_A->a() = '%s'\n", c_as_A->a()); + p += snprintf(p, end-p, "c_as_A->b() = '%s'\n", c_as_A->b()); + p += snprintf(p, end-p, "c_as_A->c() = '%s'\n", c_as_A->c()); + p += snprintf(p, end-p, "c_as_C->aa() = '%s'\n", c_as_C->aa()); + puts("");// Set first breakpoint here. + // then evaluate: + // expression a_as_A->a() + // expression a_as_A->b() + // expression a_as_A->c() + // expression b_as_A->a() + // expression b_as_A->b() + // expression b_as_A->c() + // expression b_as_B->aa() + // expression c_as_A->a() + // expression c_as_A->b() + // expression c_as_A->c() + // expression c_as_C->aa() + + return 0; +} diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/.categories b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/.categories new file mode 100644 index 00000000000..fe1da0247c6 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/.categories @@ -0,0 +1 @@ +dataformatters diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/Makefile b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/Makefile new file mode 100644 index 00000000000..a4b03ae0aab --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/Makefile @@ -0,0 +1,6 @@ +CXX_SOURCES := main.cpp +CFLAGS := -g -O0 + +clean: OBJECTS+=$(wildcard main.d.*) + +include Makefile.rules diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/TestCxxWCharT.py b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/TestCxxWCharT.py new file mode 100644 index 00000000000..b59d71e8e8e --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/TestCxxWCharT.py @@ -0,0 +1,77 @@ +# coding=utf8 +""" +Test that C++ supports wchar_t correctly. +""" + + + +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + + +class CxxWCharTTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Find the line number to break for main.cpp. + self.source = 'main.cpp' + self.line = line_number( + self.source, '// Set break point at this line.') + + def test(self): + """Test that C++ supports wchar_t correctly.""" + self.build() + exe = self.getBuildArtifact("a.out") + + # Create a target by the debugger. + target = self.dbg.CreateTarget(exe) + self.assertTrue(target, VALID_TARGET) + + # Break on the struct declration statement in main.cpp. + lldbutil.run_break_set_by_file_and_line(self, "main.cpp", self.line) + + # Now launch the process, and do not stop at entry point. + process = target.LaunchSimple( + None, None, self.get_process_working_directory()) + + if not process: + self.fail("SBTarget.Launch() failed") + + # Check that we correctly report templates on wchar_t + self.expect("frame variable foo_y", + substrs=['(Foo<wchar_t>) foo_y = ']) + + # Check that we correctly report templates on int + self.expect("frame variable foo_x", + substrs=['(Foo<int>) foo_x = ']) + + # Check that we correctly report wchar_t + self.expect("frame variable foo_y.object", + substrs=['(wchar_t) foo_y.object = ']) + + # Check that we correctly report int + self.expect("frame variable foo_x.object", + substrs=['(int) foo_x.object = ']) + + # Check that we can run expressions that return wchar_t + self.expect("expression L'a'", substrs=['(wchar_t) $', "L'a'"]) + + # Mazel Tov if this works! + self.expect("frame variable mazeltov", + substrs=['(const wchar_t *) mazeltov = ', 'L"מזל טוב"']) + + self.expect( + "frame variable ws_NULL", + substrs=['(wchar_t *) ws_NULL = 0x0']) + self.expect("frame variable ws_empty", substrs=[' L""']) + + self.expect("frame variable array", substrs=[ + 'L"Hey, I\'m a super wchar_t string']) + self.expect("frame variable array", substrs=['[0]'], matching=False) + + self.expect('frame variable wchar_zero', substrs=["L'\\0'"]) + self.expect('expression wchar_zero', substrs=["L'\\0'"]) diff --git a/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/main.cpp b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/main.cpp new file mode 100644 index 00000000000..4d6a1072d69 --- /dev/null +++ b/gnu/llvm/lldb/packages/Python/lldbsuite/test/lang/cpp/wchar_t/main.cpp @@ -0,0 +1,34 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +#include <cstring> + +template <typename T> +class Foo +{ +public: + Foo () : object() {} + Foo (T x) : object(x) {} + T getObject() { return object; } +private: + T object; +}; + + +int main (int argc, char const *argv[]) +{ + Foo<int> foo_x('a'); + Foo<wchar_t> foo_y(L'a'); + const wchar_t *mazeltov = L"מזל טוב"; + wchar_t *ws_NULL = nullptr; + wchar_t *ws_empty = L""; + wchar_t array[200], * array_source = L"Hey, I'm a super wchar_t string, éõñž"; + wchar_t wchar_zero = (wchar_t)0; + memcpy(array, array_source, 39 * sizeof(wchar_t)); + return 0; // Set break point at this line. +} |