diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/lang/cpp')
117 files changed, 4832 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/lang/cpp/auto/Makefile b/packages/Python/lldbsuite/test/lang/cpp/auto/Makefile new file mode 100644 index 000000000000..194af7b32398 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/auto/Makefile @@ -0,0 +1,7 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +CFLAGS_EXTRAS += $(NO_LIMIT_DEBUG_INFO_FLAGS) + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py b/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py new file mode 100644 index 000000000000..9746dec2fa3d --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/auto/TestCPPAuto.py @@ -0,0 +1,25 @@ +""" +Tests that auto types work +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class CPPAutoTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureGcc("GCC does not generate complete debug info") + def test_with_run_command(self): + """Test that auto types work in the expression parser""" + self.build() + self.runCmd("file 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/packages/Python/lldbsuite/test/lang/cpp/auto/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/auto/main.cpp new file mode 100644 index 000000000000..76fb95e0a34c --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/auto/main.cpp @@ -0,0 +1,16 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <string> + +int main() +{ + std::string helloworld("hello world"); + return 0; // break here +} diff --git a/packages/Python/lldbsuite/test/lang/cpp/bool/Makefile b/packages/Python/lldbsuite/test/lang/cpp/bool/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/bool/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/bool/TestCPPBool.py b/packages/Python/lldbsuite/test/lang/cpp/bool/TestCPPBool.py new file mode 100644 index 000000000000..ef7135cfaa07 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/bool/TestCPPBool.py @@ -0,0 +1,26 @@ +""" +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 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/packages/Python/lldbsuite/test/lang/cpp/bool/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/bool/main.cpp new file mode 100644 index 000000000000..88d02d5b2894 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/bool/main.cpp @@ -0,0 +1,17 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +int main() +{ + bool my_bool = false; + + printf("%s\n", my_bool ? "true" : "false"); // breakpoint 1 +} diff --git a/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/Makefile b/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/Makefile new file mode 100644 index 000000000000..1d1f38f7fd0e --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := nested.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py b/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py new file mode 100644 index 000000000000..6c06f3750d13 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/TestCPPBreakpointCommands.py @@ -0,0 +1,84 @@ +""" +Test lldb breakpoint command for CPP methods & functions in a namespace. +""" + +from __future__ import print_function + + + +import os, time +import lldb +from lldbsuite.test.lldbtest import * + +class CPPBreakpointCommandsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureWindows + def test(self): + """Test a sequence of breakpoint command add, list, and delete.""" + self.build() + exe = os.path.join(os.getcwd(), "a.out") + + # Create a target from the debugger. + + target = self.dbg.CreateTarget (exe) + self.assertTrue(target, VALID_TARGET) + + a_out_module = lldb.SBFileSpecList() + a_out_module.Append(lldb.SBFileSpec(exe)) + + nested_comp_unit = lldb.SBFileSpecList() + nested_comp_unit.Append (lldb.SBFileSpec("nested.cpp")) + + # First provide ONLY the method name. This should get everybody... + auto_break = target.BreakpointCreateByName ("Function", + lldb.eFunctionNameTypeAuto, + a_out_module, + nested_comp_unit) + self.assertTrue (auto_break.GetNumLocations() == 5) + + # Now add the Baz class specifier. This should get the version contained in Bar, + # AND the one contained in :: + auto_break = target.BreakpointCreateByName ("Baz::Function", + lldb.eFunctionNameTypeAuto, + a_out_module, + nested_comp_unit) + self.assertTrue (auto_break.GetNumLocations() == 2) + + # Then add the Bar::Baz specifier. This should get the version contained in Bar only + auto_break = target.BreakpointCreateByName ("Bar::Baz::Function", + lldb.eFunctionNameTypeAuto, + a_out_module, + nested_comp_unit) + self.assertTrue (auto_break.GetNumLocations() == 1) + + plain_method_break = target.BreakpointCreateByName ("Function", + lldb.eFunctionNameTypeMethod, + a_out_module, + nested_comp_unit) + self.assertTrue (plain_method_break.GetNumLocations() == 3) + + plain_method_break = target.BreakpointCreateByName ("Baz::Function", + lldb.eFunctionNameTypeMethod, + a_out_module, + nested_comp_unit) + self.assertTrue (plain_method_break.GetNumLocations() == 2) + + plain_method_break = target.BreakpointCreateByName ("Bar::Baz::Function", + lldb.eFunctionNameTypeMethod, + a_out_module, + nested_comp_unit) + self.assertTrue (plain_method_break.GetNumLocations() == 1) + + plain_method_break = target.BreakpointCreateByName ("Function", + lldb.eFunctionNameTypeBase, + a_out_module, + nested_comp_unit) + self.assertTrue (plain_method_break.GetNumLocations() == 2) + + plain_method_break = target.BreakpointCreateByName ("Bar::Function", + lldb.eFunctionNameTypeBase, + a_out_module, + nested_comp_unit) + self.assertTrue (plain_method_break.GetNumLocations() == 1) diff --git a/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp b/packages/Python/lldbsuite/test/lang/cpp/breakpoint-commands/nested.cpp new file mode 100644 index 000000000000..29d4b4cb19e7 --- /dev/null +++ b/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; + } + 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; + } + private: + int m_value; + }; + + static int bar_value = 20; + int Function () + { + printf ("%s returning: %d.\n", __FUNCTION__, bar_value); + return bar_value; + } + } +} + +class Baz +{ +public: + Baz (int value):m_value(value) {} + int Function () + { + printf ("%s returning: %d.\n", __FUNCTION__, m_value); + return m_value; + } +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/packages/Python/lldbsuite/test/lang/cpp/call-function/Makefile b/packages/Python/lldbsuite/test/lang/cpp/call-function/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/call-function/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py b/packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py new file mode 100644 index 000000000000..3aa97af68819 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/call-function/TestCallCPPFunction.py @@ -0,0 +1,33 @@ +""" +Tests calling a function by basename +""" + +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class CallCPPFunctionTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + TestBase.setUp(self) + self.line = line_number('main.cpp', '// breakpoint') + + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + def test_with_run_command(self): + """Test calling a function by basename""" + self.build() + self.runCmd("file 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/packages/Python/lldbsuite/test/lang/cpp/call-function/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/call-function/main.cpp new file mode 100644 index 000000000000..61a5e9d21abb --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/chained-calls/Makefile b/packages/Python/lldbsuite/test/lang/cpp/chained-calls/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/chained-calls/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py b/packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py new file mode 100644 index 000000000000..272665a78577 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/chained-calls/TestCppChainedCalls.py @@ -0,0 +1,73 @@ +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class TestCppChainedCalls(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureWindows("llvm.org/pr21765") + 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 + cwd = os.getcwd() + exe_file = "a.out" + exe_path = os.path.join(cwd, exe_file) + + # 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/packages/Python/lldbsuite/test/lang/cpp/chained-calls/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/chained-calls/main.cpp new file mode 100644 index 000000000000..a888c3f6c557 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/char1632_t/.categories b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/.categories new file mode 100644 index 000000000000..fe1da0247c62 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/.categories @@ -0,0 +1 @@ +dataformatters diff --git a/packages/Python/lldbsuite/test/lang/cpp/char1632_t/Makefile b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/Makefile new file mode 100644 index 000000000000..932046f26968 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/Makefile @@ -0,0 +1,8 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp +CFLAGS :=-g -O0 -std=c++11 + +clean: OBJECTS+=$(wildcard main.d.*) + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/char1632_t/TestChar1632T.py b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/TestChar1632T.py new file mode 100644 index 000000000000..9bb1faf4ba6d --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/TestChar1632T.py @@ -0,0 +1,90 @@ +# coding=utf8 +""" +Test that the C++11 support for char16_t and char32_t works correctly. +""" + +from __future__ import print_function + + + +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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') ] + + @expectedFailureIcc # ICC (13.1) does not emit the DW_TAG_base_type for char16_t and char32_t. + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + def test(self): + """Test that the C++11 support for char16_t and char32_t works correctly.""" + self.build() + exe = os.path.join(os.getcwd(), "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/packages/Python/lldbsuite/test/lang/cpp/char1632_t/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/main.cpp new file mode 100644 index 000000000000..b92c2d572923 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/char1632_t/main.cpp @@ -0,0 +1,44 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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/packages/Python/lldbsuite/test/lang/cpp/class_static/Makefile b/packages/Python/lldbsuite/test/lang/cpp/class_static/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_static/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py b/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py new file mode 100644 index 000000000000..d47d1b7dde41 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_static/TestStaticVariables.py @@ -0,0 +1,120 @@ +""" +Test display and Python APIs on file and class static variables. +""" + +from __future__ import print_function + + + +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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.') + + @expectedFailureWindows("llvm.org/pr24764") + def test_with_run_command(self): + """Test that file and class static variables display correctly.""" + self.build() + self.runCmd("file 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") + + @expectedFailureDarwin(9980907) + @expectedFailureClang('Clang emits incomplete debug info.') + @expectedFailureFreeBSD('llvm.org/pr20550 failing on FreeBSD-11') + @expectedFailureGcc('GCC emits incomplete debug info.') + @add_test_categories(['pyapi']) + def test_with_python_api(self): + """Test Python APIs on file and class static variables.""" + self.build() + exe = os.path.join(os.getcwd(), "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 = process.GetThreadAtIndex(0) + if thread.GetStopReason() != lldb.eStopReasonBreakpoint: + from lldbsuite.test.lldbutil import stop_reason_to_str + self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS % + stop_reason_to_str(thread.GetStopReason())) + + # 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.assertTrue(val.GetNumChildren() == 2) + elif name == 'A::g_points': + self.assertTrue(val.GetValueType() == lldb.eValueTypeVariableGlobal) + self.assertTrue(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/packages/Python/lldbsuite/test/lang/cpp/class_static/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/class_static/main.cpp new file mode 100644 index 000000000000..2068eadcac5f --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_static/main.cpp @@ -0,0 +1,53 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// 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/packages/Python/lldbsuite/test/lang/cpp/class_types/Makefile b/packages/Python/lldbsuite/test/lang/cpp/class_types/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_types/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py b/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py new file mode 100644 index 000000000000..b67e53c30745 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypes.py @@ -0,0 +1,215 @@ +"""Test breakpoint on a class constructor; and variable list the this object.""" + +from __future__ import print_function + + + +import os, time +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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 = os.path.join(os.getcwd(), "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 = os.path.join(os.getcwd(), "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.getcwd() 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 = process.GetThreadAtIndex(0) + if thread.GetStopReason() != lldb.eStopReasonBreakpoint: + from lldbsuite.test.lldbutil import stop_reason_to_str + self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS % + stop_reason_to_str(thread.GetStopReason())) + + # 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 = os.path.join(os.getcwd(), "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 = os.path.join(os.getcwd(), "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.getcwd() 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 = process.GetThreadAtIndex(0) + if thread.GetStopReason() != lldb.eStopReasonBreakpoint: + from lldbsuite.test.lldbutil import stop_reason_to_str + self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS % + stop_reason_to_str(thread.GetStopReason())) + + 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/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py b/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py new file mode 100644 index 000000000000..595d075d5180 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_types/TestClassTypesDisassembly.py @@ -0,0 +1,94 @@ +""" +Test the lldb disassemble command on each call frame when stopped on C's ctor. +""" + +from __future__ import print_function + + + +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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 = process.GetThreadAtIndex(0) + 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 = os.path.join(os.getcwd(), "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/packages/Python/lldbsuite/test/lang/cpp/class_types/cmds.txt b/packages/Python/lldbsuite/test/lang/cpp/class_types/cmds.txt new file mode 100644 index 000000000000..1c7ef9f1c8ad --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_types/cmds.txt @@ -0,0 +1,3 @@ +b main.cpp:97 +c +var diff --git a/packages/Python/lldbsuite/test/lang/cpp/class_types/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/class_types/main.cpp new file mode 100644 index 000000000000..251e66c3c9f7 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/class_types/main.cpp @@ -0,0 +1,126 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +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) + { + 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/packages/Python/lldbsuite/test/lang/cpp/diamond/Makefile b/packages/Python/lldbsuite/test/lang/cpp/diamond/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/diamond/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py b/packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py new file mode 100644 index 000000000000..67de03b54b20 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/diamond/TestDiamond.py @@ -0,0 +1,41 @@ +""" +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 = os.path.join(os.getcwd(), "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 = process.GetThreadAtIndex(0) + 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/packages/Python/lldbsuite/test/lang/cpp/diamond/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/diamond/main.cpp new file mode 100644 index 000000000000..bfe098a089f5 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/diamond/main.cpp @@ -0,0 +1,85 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#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/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/Makefile b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/Makefile new file mode 100644 index 000000000000..8770b2343ef0 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := pass-to-base.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py new file mode 100644 index 000000000000..4e23cd899285 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestCppValueCast.py @@ -0,0 +1,129 @@ +""" +Test lldb Python API SBValue::Cast(SBType) for C++ types. +""" + +from __future__ import print_function + + + +import unittest2 +import os, time +import re +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +class CppValueCastTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @unittest2.expectedFailure("rdar://problem/10808472 SBValue::Cast test case is failing (virtual inheritance)") + @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 = os.path.join(os.getcwd(), 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/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py new file mode 100644 index 000000000000..56e81c56cfa6 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/TestDynamicValue.py @@ -0,0 +1,223 @@ +""" +Use lldb Python API to test dynamic values in C++ +""" + +from __future__ import print_function + + + +import os, time +import re +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +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.') + + @expectedFailureFreeBSD # FIXME: This needs to be root-caused. + @expectedFailureWindows("llvm.org/pr24663") + @add_test_categories(['pyapi']) + def test_get_dynamic_vals(self): + """Test fetching C++ dynamic values from pointers & references.""" + self.build(dictionary=self.getBuildFlags()) + exe = os.path.join(os.getcwd(), "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/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/pass-to-base.cpp b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/pass-to-base.cpp new file mode 100644 index 000000000000..2bccf3303823 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/sbvalue-cast.cpp b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/sbvalue-cast.cpp new file mode 100644 index 000000000000..00fd7dad438c --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/dynamic-value/sbvalue-cast.cpp @@ -0,0 +1,80 @@ +//===-- sbvalue-cast.cpp ----------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#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/packages/Python/lldbsuite/test/lang/cpp/enum_types/Makefile b/packages/Python/lldbsuite/test/lang/cpp/enum_types/Makefile new file mode 100644 index 000000000000..0e0f5d1dad3d --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/enum_types/Makefile @@ -0,0 +1,10 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +CXXFLAGS += -std=c++11 + +clean: OBJECTS+=$(wildcard main.d.*) + +include $(LEVEL)/Makefile.rules + diff --git a/packages/Python/lldbsuite/test/lang/cpp/enum_types/TestCPP11EnumTypes.py b/packages/Python/lldbsuite/test/lang/cpp/enum_types/TestCPP11EnumTypes.py new file mode 100644 index 000000000000..51c145c7b7cd --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/enum_types/TestCPP11EnumTypes.py @@ -0,0 +1,110 @@ +"""Look up enum type information and check for correct display.""" + +from __future__ import print_function + + + +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class CPP11EnumTypesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def test_int8_t(self): + """Test C++11 enumeration class types as int8_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int8_t"'}) + self.image_lookup_for_enum_type() + + def test_int16_t(self): + """Test C++11 enumeration class types as int16_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int16_t"'}) + self.image_lookup_for_enum_type() + + def test_int32_t(self): + """Test C++11 enumeration class types as int32_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int32_t"'}) + self.image_lookup_for_enum_type() + + def test_int64_t(self): + """Test C++11 enumeration class types as int64_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=int64_t"'}) + self.image_lookup_for_enum_type() + + def test_uint8_t(self): + """Test C++11 enumeration class types as uint8_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint8_t"'}) + self.image_lookup_for_enum_type() + + def test_uint16_t(self): + """Test C++11 enumeration class types as uint16_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint16_t"'}) + self.image_lookup_for_enum_type() + + def test_uint32_t(self): + """Test C++11 enumeration class types as uint32_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint32_t"'}) + self.image_lookup_for_enum_type() + + def test_uint64_t(self): + """Test C++11 enumeration class types as uint64_t types.""" + self.build(dictionary={'CFLAGS_EXTRAS': '"-DTEST_BLOCK_CAPTURED_VARS=uint64_t"'}) + self.image_lookup_for_enum_type() + + 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): + """Test C++11 enumeration class types.""" + exe = os.path.join(os.getcwd(), "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, + substrs = ['enum DayType {', + 'Monday', + 'Tuesday', + 'Wednesday', + 'Thursday', + 'Friday', + 'Saturday', + 'Sunday', + 'kNumDays', + '}']) + + enum_values = [ '-4', + 'Monday', + 'Tuesday', + 'Wednesday', + 'Thursday', + 'Friday', + 'Saturday', + 'Sunday', + 'kNumDays', + '5']; + + 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/packages/Python/lldbsuite/test/lang/cpp/enum_types/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/enum_types/main.cpp new file mode 100644 index 000000000000..8595050afbbf --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/enum_types/main.cpp @@ -0,0 +1,33 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#include <stdio.h> +#include <stdint.h> + + +int main (int argc, char const *argv[]) +{ + typedef int16_t enum_integer_t; + enum class DayType : enum_integer_t { + Monday = -3, + Tuesday, + Wednesday, + Thursday, + Friday, + Saturday, + Sunday, + kNumDays + }; + enum_integer_t day_value; + 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; +} diff --git a/packages/Python/lldbsuite/test/lang/cpp/exceptions/Makefile b/packages/Python/lldbsuite/test/lang/cpp/exceptions/Makefile new file mode 100644 index 000000000000..a6bd8463ad54 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/exceptions/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := exceptions.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py b/packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py new file mode 100644 index 000000000000..65cf0b361d84 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/exceptions/TestCPPExceptionBreakpoints.py @@ -0,0 +1,65 @@ +""" +Test lldb exception breakpoint command for CPP. +""" + +from __future__ import print_function + + + +import os, time +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +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') + + @expectedFailureWindows("llvm.org/pr24538") # clang-cl does not support throw or catch + def test(self): + """Test lldb exception breakpoint command for CPP.""" + self.build() + exe = os.path.join(os.getcwd(), "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/packages/Python/lldbsuite/test/lang/cpp/exceptions/exceptions.cpp b/packages/Python/lldbsuite/test/lang/cpp/exceptions/exceptions.cpp new file mode 100644 index 000000000000..150d420b241b --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/Makefile b/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/TestFrameVariableAnonymousUnions.py b/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/TestFrameVariableAnonymousUnions.py new file mode 100644 index 000000000000..396a637041cb --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/TestFrameVariableAnonymousUnions.py @@ -0,0 +1,27 @@ +""" +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 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('frame variable -f x i', substrs=['ffffff41']) + 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/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/main.cpp new file mode 100644 index 000000000000..494b846336ff --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/frame-var-anon-unions/main.cpp @@ -0,0 +1,23 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +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/packages/Python/lldbsuite/test/lang/cpp/global_operators/Makefile b/packages/Python/lldbsuite/test/lang/cpp/global_operators/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/global_operators/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py b/packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py new file mode 100644 index 000000000000..de56cd6a6c49 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/global_operators/TestCppGlobalOperators.py @@ -0,0 +1,54 @@ +""" +Test that global operators are found and evaluated. +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class TestCppGlobalOperators(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureWindows("llvm.org/pr21765") + 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 + cwd = os.getcwd() + exe_file = "a.out" + exe_path = os.path.join(cwd, exe_file) + + # 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) + + # Check if global operators are evaluated + frame = thread.GetSelectedFrame() + + 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") diff --git a/packages/Python/lldbsuite/test/lang/cpp/global_operators/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/global_operators/main.cpp new file mode 100644 index 000000000000..a0dd0787fa32 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/global_operators/main.cpp @@ -0,0 +1,16 @@ +struct Struct { + int value; +}; + +bool operator==(const Struct &a, const Struct &b) { + return a.value == b.value; +} + +int main() { + Struct s1, s2, s3; + s1.value = 3; + s2.value = 5; + s3.value = 3; + return 0; // break here +} + diff --git a/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/Makefile b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/Makefile new file mode 100644 index 000000000000..6595e33b7269 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/Makefile @@ -0,0 +1,35 @@ +LEVEL = ../../../make + +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) $(LDFLAGS) main.o length_limit.o a.o -o limit + +nolimit: main.o length_nolimit.o a.o + $(CXX) $(LDFLAGS) main.o length_nolimit.o a.o -o nolimit + +main.o: main.cpp + $(CXX) $(CFLAGS_LIMIT) main.cpp -o main.o + +length_limit.o: length.cpp + $(CXX) $(CFLAGS_LIMIT) length.cpp -o length_limit.o + +length_nolimit.o: length.cpp + $(CXX) $(CFLAGS_NO_LIMIT) length.cpp -o length_nolimit.o + +a.o: a.cpp + $(CXX) $(CFLAGS_NO_DEBUG) -c a.cpp -o a.o + +clean: OBJECTS += limit nolimit length_limit.o length_nolimit.o length_limit.dwo length_nolimit.dwo + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py new file mode 100644 index 000000000000..324f476efb9b --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/TestCppIncompleteTypes.py @@ -0,0 +1,66 @@ +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class TestCppIncompleteTypes(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureFreeBSD("llvm.org/pr25626 test executable not built correctly on FreeBSD") + @skipIfGcc + 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") + + @skipIfGcc + @skipIfWindows # Clang on Windows asserts in external record layout in this case. + 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) + self.assertTrue(src_file_spec.IsValid(), "Main source file") + + # Get the path of the executable + cwd = os.getcwd() + exe_path = os.path.join(cwd, exe) + + # 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 + return thread.GetSelectedFrame() diff --git a/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.cpp b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.cpp new file mode 100644 index 000000000000..36b374be6f33 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.h b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/a.h new file mode 100644 index 000000000000..13e9496e3fd7 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.cpp b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.cpp new file mode 100644 index 000000000000..90a3b640f732 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.h b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/length.h new file mode 100644 index 000000000000..96df4f021808 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/incomplete-types/main.cpp new file mode 100644 index 000000000000..ad324c905818 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/Makefile b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/Makefile new file mode 100644 index 000000000000..b9a3d3fe1c81 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/Makefile @@ -0,0 +1,7 @@ +LEVEL = ../../../make + +CXX_SOURCES = main.cpp derived.cpp base.cpp + +CFLAGS_EXTRAS += $(LIMIT_DEBUG_INFO_FLAGS) + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py new file mode 100644 index 000000000000..ec26f9efe907 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/TestWithLimitDebugInfo.py @@ -0,0 +1,48 @@ +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class TestWithLimitDebugInfo(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @skipIf(debug_info=not_in(["dwarf"])) + def test_limit_debug_info(self): + self.build() + + cwd = os.getcwd() + + src_file = os.path.join(cwd, "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 = os.path.join(cwd, '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/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.cpp b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.cpp new file mode 100644 index 000000000000..4023bdbc64af --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.h b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/base.h new file mode 100644 index 000000000000..d3a09572bd25 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.cpp b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.cpp new file mode 100644 index 000000000000..9d773593eb51 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.h b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/derived.h new file mode 100644 index 000000000000..46b3f83b9f74 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/limit-debug-info/main.cpp new file mode 100644 index 000000000000..64e0349b5826 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/namespace/Makefile b/packages/Python/lldbsuite/test/lang/cpp/namespace/Makefile new file mode 100644 index 000000000000..7dd5eb4c11f1 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp ns.cpp ns2.cpp ns3.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py b/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py new file mode 100644 index 000000000000..a60d8252e9f0 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespace.py @@ -0,0 +1,125 @@ +""" +Test the printing of anonymous and named namespace variables. +""" + +from __future__ import print_function + + + +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +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 + @expectedFailureWindows("llvm.org/pr24764") + def test_with_run_command(self): + """Test that anonymous and named namespace variables display correctly.""" + self.build() + self.runCmd("file 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/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py b/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py new file mode 100644 index 000000000000..4cad45564c87 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/TestNamespaceLookup.py @@ -0,0 +1,223 @@ +""" +Test the printing of anonymous and named namespace variables. +""" + +from __future__ import print_function + + +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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']) + + @expectedFailureFreeBSD("llvm.org/pr25819") + @expectedFailureLinux("llvm.org/pr25819") + def test_scope_lookup_with_run_command(self): + """Test scope lookup of functions in lldb.""" + self.build() + self.runCmd("file 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 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") + def test_file_scope_lookup_with_run_command(self): + """Test file scope lookup in lldb.""" + self.build() + self.runCmd("file 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") + + @expectedFailureLinux("llvm.org/pr25819") + def test_scope_lookup_before_using_with_run_command(self): + """Test scope lookup before using in lldb.""" + self.build() + self.runCmd("file 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 + # emtries in DWARF - may need to add checks for compiler versions here. + @expectedFailureFreeBSD("llvm.org/pr25819") + @expectedFailureLinux("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 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 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 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") + + @expectedFailureFreeBSD("llvm.org/pr25819") + @expectedFailureLinux("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 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/packages/Python/lldbsuite/test/lang/cpp/namespace/cmds.txt b/packages/Python/lldbsuite/test/lang/cpp/namespace/cmds.txt new file mode 100644 index 000000000000..76bb1bcba759 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/cmds.txt @@ -0,0 +1,3 @@ +b main.cpp:54 +c +var diff --git a/packages/Python/lldbsuite/test/lang/cpp/namespace/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/namespace/main.cpp new file mode 100644 index 000000000000..560ec40f4733 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/main.cpp @@ -0,0 +1,124 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <cstdarg> +#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; + 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/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.cpp b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.cpp new file mode 100644 index 000000000000..9e5637d02b4b --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.cpp @@ -0,0 +1,32 @@ +//===-- ns.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "ns.h" + +int foo() +{ + printf("global foo()\n"); + return 42; +} +int func() +{ + printf("global func()\n"); + return 1; +} +int func(int a) +{ + printf("global func(int)\n"); + return a + 1; +} +void test_lookup_at_global_scope() +{ + // BP_global_scope + printf("at global scope: foo() = %d\n", foo()); // eval foo(), exp: 42 + printf("at global scope: func() = %d\n", func()); // eval func(), exp: 1 +} diff --git a/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.h b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.h new file mode 100644 index 000000000000..a07b600efa30 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns.h @@ -0,0 +1,36 @@ +//===-- ns.h ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <stdio.h> + +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() + { + printf("A::func()\n"); + return 3; + } + inline int func2() + { + 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(); + } +} diff --git a/packages/Python/lldbsuite/test/lang/cpp/namespace/ns2.cpp b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns2.cpp new file mode 100644 index 000000000000..04046ad9b7f4 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns2.cpp @@ -0,0 +1,65 @@ +//===-- ns2.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "ns.h" + +static int func() +{ + printf("static m2.cpp func()\n"); + return 2; +} +void test_lookup_at_file_scope() +{ + // BP_file_scope + printf("at file scope: func() = %d\n", func()); // eval func(), exp: 2 + printf("at file scope: func(10) = %d\n", func(10)); // eval func(10), exp: 11 +} +namespace A { + namespace B { + int func() + { + printf("A::B::func()\n"); + return 4; + } + void test_lookup_at_nested_ns_scope() + { + // BP_nested_ns_scope + 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; + printf("at nested ns scope after using: func() = %d\n", func()); // eval func(), exp: 3 + } + } +} +int A::foo() +{ + printf("A::foo()\n"); + return 42; +} +int A::func(int a) +{ + printf("A::func(int)\n"); + return a + 3; +} +void A::test_lookup_at_ns_scope() +{ + // BP_ns_scope + printf("at nested ns scope: func() = %d\n", func()); // eval func(), exp: 3 + printf("at nested ns scope: func(10) = %d\n", func(10)); // eval func(10), exp: 13 + printf("at nested ns scope: foo() = %d\n", foo()); // eval foo(), exp: 42 +} diff --git a/packages/Python/lldbsuite/test/lang/cpp/namespace/ns3.cpp b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns3.cpp new file mode 100644 index 000000000000..10b0df784225 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/namespace/ns3.cpp @@ -0,0 +1,27 @@ +//===-- ns3.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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 + 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 + printf("after using directive: func2() = %d\n", func2()); // eval func2(), exp: 3 + printf("after using directive: ::func() = %d\n", ::func()); // eval ::func(), exp: 1 + printf("after using directive: B::func() = %d\n", B::func()); // eval B::func(), exp: 4 +} diff --git a/packages/Python/lldbsuite/test/lang/cpp/nsimport/Makefile b/packages/Python/lldbsuite/test/lang/cpp/nsimport/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/nsimport/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py b/packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py new file mode 100644 index 000000000000..97e9e27a6e98 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/nsimport/TestCppNsImport.py @@ -0,0 +1,101 @@ +""" +Tests imported namespaces in C++. +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class TestCppNsImport(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureFreeBSD("llvm.org/pr25925") + @expectedFailureGcc(None, ['>=', '4.9']) + def test_with_run_command(self): + """Tests imported namespaces in C++.""" + 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 + cwd = os.getcwd() + exe_file = "a.out" + exe_path = os.path.join(cwd, exe_file) + + # 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.GetError().Fail(), "imported is ambiguous") + + 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/packages/Python/lldbsuite/test/lang/cpp/nsimport/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/nsimport/main.cpp new file mode 100644 index 000000000000..e125ebaa2430 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/Makefile b/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/Makefile new file mode 100644 index 000000000000..a8d5c4eb0268 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp static-a.cpp static-b.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py b/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py new file mode 100644 index 000000000000..d485dcd0f652 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/TestOverloadedFunctions.py @@ -0,0 +1,36 @@ +""" +Tests that functions with the same name are resolved correctly. +""" + +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class CPPStaticMethodsTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + TestBase.setUp(self) + self.line = line_number('main.cpp', '// breakpoint') + + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + def test_with_run_command(self): + """Test that functions with the same name are resolved correctly""" + self.build() + self.runCmd("file 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/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/main.cpp new file mode 100644 index 000000000000..250e2cd1d96c --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-a.cpp b/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-a.cpp new file mode 100644 index 000000000000..7250fa4bed5e --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-b.cpp b/packages/Python/lldbsuite/test/lang/cpp/overloaded-functions/static-b.cpp new file mode 100644 index 000000000000..90a20f69e6db --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/Makefile b/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/Makefile new file mode 100644 index 000000000000..1476447db355 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/Makefile @@ -0,0 +1,8 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp +CFLAGS := -g -O0 -std=c++11 + +clean: OBJECTS+=$(wildcard main.d.*) + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/TestRdar12991846.py b/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/TestRdar12991846.py new file mode 100644 index 000000000000..636a82b425da --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/TestRdar12991846.py @@ -0,0 +1,85 @@ +# coding=utf8 +""" +Test that the expression parser returns proper Unicode strings. +""" + +from __future__ import print_function + + + +import unittest2 +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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 Rdar12991846TestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @unittest2.expectedFailure("rdar://18684408") + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + def test_expr1(self): + """Test that the expression parser returns proper Unicode strings.""" + self.build() + self.rdar12991846(expr=1) + + @unittest2.expectedFailure("rdar://18684408") + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + def test_expr2(self): + """Test that the expression parser returns proper Unicode strings.""" + self.build() + self.rdar12991846(expr=2) + + @unittest2.expectedFailure("rdar://18684408") + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + 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 = os.path.join(os.getcwd(), "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/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/main.cpp new file mode 100644 index 000000000000..fda951a78991 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/rdar12991846/main.cpp @@ -0,0 +1,21 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + + +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/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/Makefile b/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/Makefile new file mode 100644 index 000000000000..3a1d8a579350 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/Makefile @@ -0,0 +1,7 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +CXXFLAGS += -std=c++11 + +include $(LEVEL)/Makefile.rules
\ No newline at end of file diff --git a/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py b/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py new file mode 100644 index 000000000000..d02c34ecb0fe --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/TestRvalueReferences.py @@ -0,0 +1,49 @@ +""" +Tests that rvalue references are supported in C++ +""" + +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class RvalueReferencesTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + #rdar://problem/11479676 + @expectedFailureIcc("ICC (13.1, 14-beta) do not emit DW_TAG_rvalue_reference_type.") + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + def test_with_run_command(self): + """Test that rvalues are supported in the C++ expression parser""" + self.build() + self.runCmd("file 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/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/rvalue-references/main.cpp new file mode 100644 index 000000000000..6da34c73f101 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/scope/Makefile b/packages/Python/lldbsuite/test/lang/cpp/scope/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/scope/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py b/packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py new file mode 100644 index 000000000000..66d4a1591575 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/scope/TestCppScope.py @@ -0,0 +1,67 @@ +""" +Test scopes in C++. +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class TestCppScopes(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @expectedFailureDarwin + @expectedFailureWindows("llvm.org/pr24764") + 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 + cwd = os.getcwd() + exe_file = "a.out" + exe_path = os.path.join(cwd, exe_file) + + # 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: + 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/packages/Python/lldbsuite/test/lang/cpp/scope/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/scope/main.cpp new file mode 100644 index 000000000000..da5d7ed529d1 --- /dev/null +++ b/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/packages/Python/lldbsuite/test/lang/cpp/signed_types/Makefile b/packages/Python/lldbsuite/test/lang/cpp/signed_types/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/signed_types/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py b/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py new file mode 100644 index 000000000000..51e6d4579e28 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/signed_types/TestSignedTypes.py @@ -0,0 +1,60 @@ +""" +Test that variables with signed types display correctly. +""" + +from __future__ import print_function + + + +import os, time +import re +import lldb +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.source = 'main.cpp' + self.line = line_number(self.source, '// Set break point at this line.') + + 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("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 assignment statement. + 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/packages/Python/lldbsuite/test/lang/cpp/signed_types/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/signed_types/main.cpp new file mode 100644 index 000000000000..dbf3606aeba8 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/signed_types/main.cpp @@ -0,0 +1,33 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#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/packages/Python/lldbsuite/test/lang/cpp/static_members/Makefile b/packages/Python/lldbsuite/test/lang/cpp/static_members/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/static_members/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py b/packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py new file mode 100644 index 000000000000..1c41b1b6f571 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/static_members/TestCPPStaticMembers.py @@ -0,0 +1,59 @@ +""" +Tests that C++ member and static variables have correct layout and scope. +""" + +from __future__ import print_function + + + +import unittest2 +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class CPPStaticMembersTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + @unittest2.expectedFailure # llvm.org/pr15401 + @expectedFailureWindows("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 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/packages/Python/lldbsuite/test/lang/cpp/static_members/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/static_members/main.cpp new file mode 100644 index 000000000000..7ccc2f9a328b --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/static_members/main.cpp @@ -0,0 +1,36 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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/packages/Python/lldbsuite/test/lang/cpp/static_methods/Makefile b/packages/Python/lldbsuite/test/lang/cpp/static_methods/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/static_methods/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py b/packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py new file mode 100644 index 000000000000..dba556431e39 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/static_methods/TestCPPStaticMethods.py @@ -0,0 +1,36 @@ +""" +Tests expressions that distinguish between static and non-static methods. +""" + +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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') + + @expectedFailureWindows + def test_with_run_command(self): + """Test that static methods are properly distinguished from regular methods""" + self.build() + self.runCmd("file 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/packages/Python/lldbsuite/test/lang/cpp/static_methods/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/static_methods/main.cpp new file mode 100644 index 000000000000..5141a407d111 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/static_methods/main.cpp @@ -0,0 +1,38 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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/packages/Python/lldbsuite/test/lang/cpp/stl/Makefile b/packages/Python/lldbsuite/test/lang/cpp/stl/Makefile new file mode 100644 index 000000000000..f61a6300a994 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/stl/Makefile @@ -0,0 +1,15 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp +CFLAGS := -g -O0 + +clean: OBJECTS+=$(wildcard main.d.*) + +# clang-3.5+ outputs FullDebugInfo by default for Darwin/FreeBSD +# targets. Other targets do not, which causes this test to fail. +# This flag enables FullDebugInfo for all targets. +ifneq (,$(findstring clang,$(CC))) + CFLAGS_EXTRAS += -fno-limit-debug-info +endif + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/stl/TestSTL.py b/packages/Python/lldbsuite/test/lang/cpp/stl/TestSTL.py new file mode 100644 index 000000000000..6dba1398947e --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/stl/TestSTL.py @@ -0,0 +1,118 @@ +""" +Test some expressions involving STL data types. +""" + +from __future__ import print_function + + + +import unittest2 +import os, time +import lldb +import lldbsuite.test.lldbutil as lldbutil +from lldbsuite.test.lldbtest import * + +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.') + + # rdar://problem/10400981 + @unittest2.expectedFailure + def test(self): + """Test some expressions involving STL data types.""" + self.build() + exe = os.path.join(os.getcwd(), "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) + + # rdar://problem/8543077 + # test/stl: clang built binaries results in the breakpoint locations = 3, + # is this a problem with clang generated debug info? + 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]); }') + + # rdar://problem/10373783 + # rdar://problem/10400981 + 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']) + + @expectedFailureIcc # icc 13.1 and 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 = os.path.join(os.getcwd(), '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/packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py b/packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py new file mode 100644 index 000000000000..d7435c467274 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/stl/TestStdCXXDisassembly.py @@ -0,0 +1,111 @@ +""" +Test the lldb disassemble command on lib stdc++. +""" + +from __future__ import print_function + + + +import unittest2 +import os, time +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +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.') + + # rdar://problem/8504895 + # Crash while doing 'disassemble -n "-[NSNumber descriptionWithLocale:]" + @unittest2.skipIf(TestBase.skipLongRunningTest(), "Skip this long running test") + def test_stdcxx_disasm(self): + """Do 'disassemble' on each and every 'Code' symbol entry from the std c++ lib.""" + self.build() + exe = os.path.join(os.getcwd(), "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 = process.GetThreadAtIndex(0) + 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/packages/Python/lldbsuite/test/lang/cpp/stl/cmds.txt b/packages/Python/lldbsuite/test/lang/cpp/stl/cmds.txt new file mode 100644 index 000000000000..9c9c2e3db57b --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/stl/cmds.txt @@ -0,0 +1,3 @@ +b main.cpp:6 +continue +var diff --git a/packages/Python/lldbsuite/test/lang/cpp/stl/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/stl/main.cpp new file mode 100644 index 000000000000..cfdb7b2d3db5 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/stl/main.cpp @@ -0,0 +1,30 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#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/packages/Python/lldbsuite/test/lang/cpp/this/Makefile b/packages/Python/lldbsuite/test/lang/cpp/this/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/this/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py b/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py new file mode 100644 index 000000000000..07cc2e8e9788 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/this/TestCPPThis.py @@ -0,0 +1,53 @@ +""" +Tests that C++ member and static variables are available where they should be. +""" +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as lldbutil + +class CPPThisTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + #rdar://problem/9962849 + @expectedFailureGcc # llvm.org/pr15439 The 'this' pointer isn't available during expression evaluation when stopped in an inlined member function. + @expectedFailureIcc # ICC doesn't emit correct DWARF inline debug info for inlined member functions + @expectedFailureWindows("llvm.org/pr24489: Name lookup not working correctly on Windows") + @expectedFailureWindows("llvm.org/pr24490: We shouldn't be using platform-specific names like `getpid` in tests") + @expectedFlakeyClang(bugnumber='llvm.org/pr23012', compiler_version=['>=','3.6']) # failed with totclang - clang3.7 + 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 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/packages/Python/lldbsuite/test/lang/cpp/this/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/this/main.cpp new file mode 100644 index 000000000000..4448a5cadf57 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/this/main.cpp @@ -0,0 +1,53 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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/packages/Python/lldbsuite/test/lang/cpp/unique-types/Makefile b/packages/Python/lldbsuite/test/lang/cpp/unique-types/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/unique-types/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/unique-types/TestUniqueTypes.py b/packages/Python/lldbsuite/test/lang/cpp/unique-types/TestUniqueTypes.py new file mode 100644 index 000000000000..2cbb1a191e68 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/unique-types/TestUniqueTypes.py @@ -0,0 +1,62 @@ +""" +Test that template instaniations of std::vector<long> and <short> in the same module have the correct types. +""" + +from __future__ import print_function + + + +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) + if "clang" in compiler_basename and int(self.getCompilerVersion().split('.')[0]) < 3: + self.skipTest("rdar://problem/9173060 lldb hangs while running unique-types for clang version < 3") + + exe = os.path.join(os.getcwd(), "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/packages/Python/lldbsuite/test/lang/cpp/unique-types/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/unique-types/main.cpp new file mode 100644 index 000000000000..c551c0e2c0d4 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/unique-types/main.cpp @@ -0,0 +1,24 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#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/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/Makefile b/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py b/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py new file mode 100644 index 000000000000..c137592558ed --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/TestUnsignedTypes.py @@ -0,0 +1,54 @@ +""" +Test that variables with unsigned types display correctly. +""" + +from __future__ import print_function + + + +import os, time +import re +import lldb +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 = os.path.join(os.getcwd(), "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() aftre 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, + startstr = "(unsigned char) the_unsigned_char = 'c'", + patterns = ["\((short unsigned int|unsigned short)\) the_unsigned_short = 99"], + substrs = ["(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/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/main.cpp new file mode 100644 index 000000000000..b0d68377e983 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/unsigned_types/main.cpp @@ -0,0 +1,22 @@ +//===-- main.cpp ------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +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/packages/Python/lldbsuite/test/lang/cpp/virtual/Makefile b/packages/Python/lldbsuite/test/lang/cpp/virtual/Makefile new file mode 100644 index 000000000000..314f1cb2f077 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/virtual/Makefile @@ -0,0 +1,5 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py b/packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py new file mode 100644 index 000000000000..1553a43e1a73 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/virtual/TestVirtual.py @@ -0,0 +1,90 @@ +""" +Test C++ virtual function and virtual inheritance. +""" + +from __future__ import print_function + +import os, time +import re +import lldb +from lldbsuite.test.lldbtest import * +import lldbsuite.test.lldbutil as 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("^([^=]*) = '([^=]*)'$") + + # Assert message. + PRINTF_OUTPUT_GROKKED = "The printf output from compiled code is parsed correctly" + + 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.') + + @expectedFailureIcc('llvm.org/pr16808') # lldb does not call the correct virtual function with icc + @expectedFailureAll(oslist=['windows']) + 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("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 from the + # series of printf statements. + stdout = process.GetSTDOUT(1024) + + self.assertIsNotNone(stdout, "Encountered an error reading the process's output") + + # 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 stdout.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/packages/Python/lldbsuite/test/lang/cpp/virtual/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/virtual/main.cpp new file mode 100644 index 000000000000..bed1422dcbdd --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/virtual/main.cpp @@ -0,0 +1,113 @@ +#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; + + printf ("a_as_A->a() = '%s'\n", a_as_A->a()); + printf ("a_as_A->b() = '%s'\n", a_as_A->b()); + printf ("a_as_A->c() = '%s'\n", a_as_A->c()); + printf ("b_as_A->a() = '%s'\n", b_as_A->a()); + printf ("b_as_A->b() = '%s'\n", b_as_A->b()); + printf ("b_as_A->c() = '%s'\n", b_as_A->c()); + printf ("b_as_B->aa() = '%s'\n", b_as_B->aa()); + printf ("c_as_A->a() = '%s'\n", c_as_A->a()); + printf ("c_as_A->b() = '%s'\n", c_as_A->b()); + printf ("c_as_A->c() = '%s'\n", c_as_A->c()); + printf ("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/packages/Python/lldbsuite/test/lang/cpp/wchar_t/.categories b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/.categories new file mode 100644 index 000000000000..fe1da0247c62 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/.categories @@ -0,0 +1 @@ +dataformatters diff --git a/packages/Python/lldbsuite/test/lang/cpp/wchar_t/Makefile b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/Makefile new file mode 100644 index 000000000000..fe27980afe9b --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/Makefile @@ -0,0 +1,8 @@ +LEVEL = ../../../make + +CXX_SOURCES := main.cpp +CFLAGS := -g -O0 + +clean: OBJECTS+=$(wildcard main.d.*) + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/lang/cpp/wchar_t/TestCxxWCharT.py b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/TestCxxWCharT.py new file mode 100644 index 000000000000..f9cdbca16e55 --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/TestCxxWCharT.py @@ -0,0 +1,74 @@ +#coding=utf8 +""" +Test that C++ supports wchar_t correctly. +""" + +from __future__ import print_function + + + +import os, time +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 = os.path.join(os.getcwd(), "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/packages/Python/lldbsuite/test/lang/cpp/wchar_t/main.cpp b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/main.cpp new file mode 100644 index 000000000000..e249c37b678f --- /dev/null +++ b/packages/Python/lldbsuite/test/lang/cpp/wchar_t/main.cpp @@ -0,0 +1,35 @@ +//===-- main.c --------------------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#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. +} |