Vendor import of lldb trunk r256945:

https://llvm.org/svn/llvm-project/lldb/trunk@256945

26 files changed, 1097 insertions, 0 deletions

diff --git a/packages/Python/lldbsuite/test/macosx/add-dsym/Makefile b/packages/Python/lldbsuite/test/macosx/add-dsym/Makefile
new file mode 100644
index 0000000..4e4aa71
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/add-dsym/Makefile
@@ -0,0 +1,11 @@
+CC ?= clang
+
+all: clean
+	mkdir hide.app
+	mkdir hide.app/Contents
+	$(CC) -g main.c
+	mv a.out.dSYM hide.app/Contents
+	strip -x a.out
+
+clean:
+	rm -rf a.out a.out.dSYM hide.app
diff --git a/packages/Python/lldbsuite/test/macosx/add-dsym/TestAddDsymMidExecutionCommand.py b/packages/Python/lldbsuite/test/macosx/add-dsym/TestAddDsymMidExecutionCommand.py
new file mode 100644
index 0000000..497f695
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/add-dsym/TestAddDsymMidExecutionCommand.py
@@ -0,0 +1,45 @@
+"""Test that the 'add-dsym', aka 'target symbols add', succeeds in the middle of debug session."""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+import sys
+from lldbsuite.test.lldbtest import *
+
+@skipUnlessDarwin
+class AddDsymMidExecutionCommandCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        self.source = 'main.c'
+
+    @no_debug_info_test # Prevent the genaration of the dwarf version of this test
+    def test_add_dsym_mid_execution(self):
+        """Test that add-dsym mid-execution loads the symbols at the right place for a slid binary."""
+        self.buildDsym(clean=True)
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        self.target = self.dbg.CreateTarget(exe)
+        self.assertTrue(self.target, VALID_TARGET)
+
+        main_bp = self.target.BreakpointCreateByName ("main", "a.out")
+        self.assertTrue(main_bp, VALID_BREAKPOINT)
+
+        self.runCmd("settings set target.disable-aslr false")
+        self.process = self.target.LaunchSimple (None, None, self.get_process_working_directory())
+        self.assertTrue(self.process, PROCESS_IS_VALID)
+
+        # The stop reason of the thread should be breakpoint.
+        self.assertTrue(self.process.GetState() == lldb.eStateStopped,
+                        STOPPED_DUE_TO_BREAKPOINT)
+
+        self.runCmd("add-dsym hide.app/Contents/a.out.dSYM")
+
+        self.expect("frame select",
+                    substrs = ['a.out`main at main.c'])
diff --git a/packages/Python/lldbsuite/test/macosx/add-dsym/main.c b/packages/Python/lldbsuite/test/macosx/add-dsym/main.c
new file mode 100644
index 0000000..da9e09f
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/add-dsym/main.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+static int var = 5;
+int main ()
+{
+    printf ("%p is %d\n", &var, var); // break on this line
+    return ++var;
+}
diff --git a/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/Makefile b/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/Makefile
new file mode 100644
index 0000000..aa3a0fc
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/Makefile
@@ -0,0 +1,6 @@
+LEVEL = ../../../make
+
+C_SOURCES := main.c
+MAKE_DSYM := NO
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/TestAppleTypesIsProduced.py b/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/TestAppleTypesIsProduced.py
new file mode 100644
index 0000000..fad14db
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/TestAppleTypesIsProduced.py
@@ -0,0 +1,67 @@
+"""
+Test that clang produces the __apple accelerator tables, for example, __apple_types, correctly.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.lldbutil import symbol_type_to_str
+
+class AppleTypesTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    #rdar://problem/11166975
+    @skipUnlessDarwin
+    def test_debug_info_for_apple_types(self):
+        """Test that __apple_types section does get produced by clang."""
+
+        if not self.getCompiler().endswith('clang'):
+            self.skipTest("clang compiler only test")
+
+        self.build()
+        if self.debug_info == "dsym":
+            exe = os.path.join(os.getcwd(), "a.out.dSYM/Contents/Resources/DWARF/a.out")
+        else:
+            exe = os.path.join(os.getcwd(), "main.o")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+        self.assertTrue(target.GetNumModules() > 0)
+
+        # Hide stdout if not running with '-t' option.
+        if not self.TraceOn():
+            self.HideStdout()
+
+        print("Number of modules for the target: %d" % target.GetNumModules())
+        for module in target.module_iter():
+            print(module)
+
+        # Get the executable module at index 0.
+        exe_module = target.GetModuleAtIndex(0)
+
+        dwarf_section = exe_module.FindSection("__DWARF")
+        self.assertTrue(dwarf_section)
+        print("__DWARF section:", dwarf_section)
+        print("Number of sub-sections: %d" % dwarf_section.GetNumSubSections())
+        INDENT = ' ' * 4
+        for subsec in dwarf_section:
+            print(INDENT + str(subsec))
+
+        debug_str_sub_section = dwarf_section.FindSubSection("__debug_str")
+        self.assertTrue(debug_str_sub_section)
+        print("__debug_str sub-section:", debug_str_sub_section)
+
+        # Find our __apple_types section by name.
+        apple_types_sub_section = dwarf_section.FindSubSection("__apple_types")
+        self.assertTrue(apple_types_sub_section)
+        print("__apple_types sub-section:", apple_types_sub_section)
+
+        # These other three all important subsections should also be present.
+        self.assertTrue(dwarf_section.FindSubSection("__apple_names") and
+                        dwarf_section.FindSubSection("__apple_namespac") and
+                        dwarf_section.FindSubSection("__apple_objc"))
diff --git a/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/main.c b/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/main.c
new file mode 100644
index 0000000..cb4bdb9
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/debug-info/apple_types/main.c
@@ -0,0 +1,27 @@
+//===-- 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[])
+{
+    struct point_tag {
+        int x;
+        int y;
+    }; // Set break point at this line.
+
+    struct rect_tag {
+        struct point_tag bottom_left;
+        struct point_tag top_right;
+    };
+    struct point_tag pt = { 2, 3 }; // This is the first executable statement.
+    struct rect_tag rect = {{1,2}, {3,4}};
+    pt.x = argc;
+    pt.y = argc * argc;
+    rect.top_right.x = rect.top_right.x + argc;
+        rect.top_right.y = rect.top_right.y + argc;
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/macosx/indirect_symbol/Makefile b/packages/Python/lldbsuite/test/macosx/indirect_symbol/Makefile
new file mode 100644
index 0000000..07aa39e
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/indirect_symbol/Makefile
@@ -0,0 +1,48 @@
+CC ?= clang
+ifeq "$(ARCH)" ""
+	ARCH = x86_64
+endif
+
+ifeq "$(OS)" ""
+	OS = $(shell uname -s)
+endif
+
+CFLAGS ?= -g -O0
+CWD := $(shell pwd)
+
+LIB_PREFIX := lib
+
+ifeq "$(OS)" "Darwin"
+	CFLAGS += -arch $(ARCH)
+	DS := dsymutil
+	LD_FLAGS := -dynamiclib
+	LIB_INDIRECT := $(LIB_PREFIX)indirect.dylib
+	LIB_REEXPORT := $(LIB_PREFIX)reexport.dylib
+	EXEC_PATH := "@executable_path"
+	EXEC_PATH_INDIRECT := -install_name $(EXEC_PATH)/$(LIB_INDIRECT)
+	EXEC_PATH_REEXPORT := -install_name $(EXEC_PATH)/$(LIB_REEXPORT)
+endif
+
+all: a.out $(LIB_INDIRECT) $(LIB_REEXPORT)
+
+a.out: main.o $(LIB_INDIRECT) $(LIB_REEXPORT)
+	$(CC) $(CFLAGS) -o a.out main.o -L. $(LIB_INDIRECT) $(LIB_REEXPORT)
+
+main.o: main.c
+	$(CC) $(CFLAGS) -c main.c
+
+$(LIB_INDIRECT): indirect.o
+	$(CC) $(CFLAGS) $(LD_FLAGS) $(EXEC_PATH_INDIRECT) -o $(LIB_INDIRECT) indirect.o
+	if [ "$(OS)" = "Darwin" ]; then dsymutil $(LIB_INDIRECT); fi
+
+indirect.o: indirect.c
+	$(CC) $(CFLAGS) -c indirect.c
+
+$(LIB_REEXPORT): reexport.o $(LIB_INDIRECT)
+	$(CC) $(CFLAGS) $(LD_FLAGS) $(EXEC_PATH_REEXPORT) -o $(LIB_REEXPORT) reexport.o -L. -lindirect -Wl,-alias_list,$(CWD)/alias.list
+	if [ "$(OS)" = "Darwin" ]; then dsymutil $(LIB_REEXPORT); fi
+
+reexport.o: reexport.c
+	$(CC) $(CFLAGS) -c reexport.c
+clean:
+	rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM)
diff --git a/packages/Python/lldbsuite/test/macosx/indirect_symbol/TestIndirectSymbols.py b/packages/Python/lldbsuite/test/macosx/indirect_symbol/TestIndirectSymbols.py
new file mode 100644
index 0000000..4f98865
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/indirect_symbol/TestIndirectSymbols.py
@@ -0,0 +1,88 @@
+"""Test stepping and setting breakpoints in indirect and re-exported symbols."""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class TestIndirectFunctions(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line numbers that we will step to in main:
+        self.main_source = "main.c"
+
+    @skipUnlessDarwin
+    @add_test_categories(['pyapi'])
+    def test_with_python_api(self):
+        """Test stepping and setting breakpoints in indirect and re-exported symbols."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        self.main_source_spec = lldb.SBFileSpec (self.main_source)
+
+        break1 = target.BreakpointCreateBySourceRegex ("Set breakpoint here to step in indirect.", self.main_source_spec)
+        self.assertTrue(break1, VALID_BREAKPOINT)
+
+        break2 = target.BreakpointCreateBySourceRegex ("Set breakpoint here to step in reexported.", self.main_source_spec)
+        self.assertTrue(break2, 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.
+        threads = lldbutil.get_threads_stopped_at_breakpoint (process, break1)
+        if len(threads) != 1:
+            self.fail ("Failed to stop at breakpoint 1.")
+
+        thread = threads[0]
+
+        # Now do a step-into, and we should end up in the hidden target of this indirect function.
+        thread.StepInto()
+        curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
+        self.assertTrue (curr_function == "call_through_indirect_hidden", "Stepped into indirect symbols.")
+
+        # Now set a breakpoint using the indirect symbol name, and make sure we get to that:
+        break_indirect = target.BreakpointCreateByName ("call_through_indirect");
+        self.assertTrue (break_indirect, VALID_BREAKPOINT)
+
+        # Now continue should take us to the second call through the indirect symbol:
+
+        threads = lldbutil.continue_to_breakpoint (process, break_indirect)
+        self.assertTrue (len(threads) == 1, "Stopped at breakpoint in indirect function.")
+        curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
+        self.assertTrue (curr_function == "call_through_indirect_hidden", "Stepped into indirect symbols.")
+
+        # Delete this breakpoint so it won't get in the way:
+        target.BreakpointDelete (break_indirect.GetID())
+
+        # Now continue to the site of the first re-exported function call in main:
+        threads = lldbutil.continue_to_breakpoint (process, break2)
+
+        # This is stepping Into through a re-exported symbol to an indirect symbol:
+        thread.StepInto()
+        curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
+        self.assertTrue (curr_function == "call_through_indirect_hidden", "Stepped into indirect symbols.")
+
+        # And the last bit is to set a breakpoint on the re-exported symbol and make sure we are again in out target function.
+        break_reexported = target.BreakpointCreateByName ("reexport_to_indirect");
+        self.assertTrue (break_reexported, VALID_BREAKPOINT)
+
+        # Now continue should take us to the second call through the indirect symbol:
+
+        threads = lldbutil.continue_to_breakpoint (process, break_reexported)
+        self.assertTrue (len(threads) == 1, "Stopped at breakpoint in reexported function target.")
+        curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
+        self.assertTrue (curr_function == "call_through_indirect_hidden", "Stepped into indirect symbols.")
diff --git a/packages/Python/lldbsuite/test/macosx/indirect_symbol/alias.list b/packages/Python/lldbsuite/test/macosx/indirect_symbol/alias.list
new file mode 100644
index 0000000..3232c58
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/indirect_symbol/alias.list
@@ -0,0 +1 @@
+_call_through_indirect _reexport_to_indirect
\ No newline at end of file
diff --git a/packages/Python/lldbsuite/test/macosx/indirect_symbol/indirect.c b/packages/Python/lldbsuite/test/macosx/indirect_symbol/indirect.c
new file mode 100644
index 0000000..48e1459
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/indirect_symbol/indirect.c
@@ -0,0 +1,14 @@
+#define MakeResolver(name)                                       \
+  void * name ## Resolver(void) __asm__("_" #name);              \
+  void * name ## Resolver(void) {                                \
+    __asm__(".symbol_resolver _" #name);                         \
+    return name ## _hidden;                                    \
+  }
+
+int 
+call_through_indirect_hidden(int arg)
+{
+  return arg + 5;
+}
+
+MakeResolver(call_through_indirect)
diff --git a/packages/Python/lldbsuite/test/macosx/indirect_symbol/main.c b/packages/Python/lldbsuite/test/macosx/indirect_symbol/main.c
new file mode 100644
index 0000000..b5af058
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/indirect_symbol/main.c
@@ -0,0 +1,14 @@
+extern int call_through_indirect(int);
+extern int reexport_to_indirect(int);
+
+int
+main ()
+{
+  int indirect_result = call_through_indirect(20); // Set breakpoint here to step in indirect.
+  indirect_result = call_through_indirect(30);
+
+  int reexport_result = reexport_to_indirect (20); // Set breakpoint here to step in reexported.
+  reexport_result = reexport_to_indirect (30);
+
+  return 0;
+}
diff --git a/packages/Python/lldbsuite/test/macosx/indirect_symbol/reexport.c b/packages/Python/lldbsuite/test/macosx/indirect_symbol/reexport.c
new file mode 100644
index 0000000..096a463
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/indirect_symbol/reexport.c
@@ -0,0 +1,7 @@
+extern int call_through_indirect(int);
+
+int
+fake_call_through_reexport(int value)
+{
+  return value + 10;
+}
diff --git a/packages/Python/lldbsuite/test/macosx/order/Makefile b/packages/Python/lldbsuite/test/macosx/order/Makefile
new file mode 100644
index 0000000..52fae2d
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/order/Makefile
@@ -0,0 +1,7 @@
+LEVEL = ../../make
+
+C_SOURCES := main.c
+LDFLAGS = $(CFLAGS) -Xlinker -order_file -Xlinker ./order-file
+MAKE_DSYM := NO
+
+include $(LEVEL)/Makefile.rules
diff --git a/packages/Python/lldbsuite/test/macosx/order/TestOrderFile.py b/packages/Python/lldbsuite/test/macosx/order/TestOrderFile.py
new file mode 100644
index 0000000..6541169
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/order/TestOrderFile.py
@@ -0,0 +1,36 @@
+"""
+Test that debug symbols have the correct order as specified by the order file.
+"""
+
+from __future__ import print_function
+
+
+
+import os, time
+import re
+import lldb
+from lldbsuite.test.lldbtest import *
+
+class OrderFileTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    def test(self):
+        """Test debug symbols follow the correct order by the order file."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # Test that the debug symbols have Function f3 before Function f1.
+        # Use "-s address" option to sort by address.
+        self.runCmd("image dump symtab -s address a.out")
+        output = self.res.GetOutput()
+        mo_f3 = re.search("Code +.+f3", output)
+        mo_f1 = re.search("Code +.+f1", output)
+        
+        # Match objects for f3 and f1 must exist and f3 must come before f1.
+        self.assertTrue(mo_f3 and mo_f1 and mo_f3.start() < mo_f1.start(),
+                        "Symbols have correct order by the order file")
+
+        self.runCmd("run", RUN_COMPLETED)
diff --git a/packages/Python/lldbsuite/test/macosx/order/cmds.txt b/packages/Python/lldbsuite/test/macosx/order/cmds.txt
new file mode 100644
index 0000000..8c51dd7
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/order/cmds.txt
@@ -0,0 +1,3 @@
+b main.c:41
+c
+lines -shlib a.out main.c
diff --git a/packages/Python/lldbsuite/test/macosx/order/main.c b/packages/Python/lldbsuite/test/macosx/order/main.c
new file mode 100644
index 0000000..cd1ea58
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/order/main.c
@@ -0,0 +1,54 @@
+//===-- 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>
+
+
+int f1 (char *s);
+int f2 (char *s);
+int f3 (char *s);
+
+
+// We want f1 to start on line 20
+int f1 (char *s)
+{
+    return printf("f1: %s\n", s);
+}
+
+
+
+
+
+// We want f2 to start on line 30
+int f2 (char *s)
+{
+    return printf("f2: %s\n", s);
+}
+
+
+
+
+
+// We want f3 to start on line 40
+int f3 (char *s)
+{
+    return printf("f3: %s\n", s);
+}
+
+
+
+
+
+// We want main to start on line 50
+int main (int argc, const char * argv[])
+{
+    f1("carp");
+    f2("ding");
+    f3("dong");
+    return 0;
+}
diff --git a/packages/Python/lldbsuite/test/macosx/order/order-file b/packages/Python/lldbsuite/test/macosx/order/order-file
new file mode 100644
index 0000000..0cf8ecd
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/order/order-file
@@ -0,0 +1,4 @@
+main.o:_f3
+main.o:_main
+main.o:_f2
+main.o:_f1
diff --git a/packages/Python/lldbsuite/test/macosx/queues/Makefile b/packages/Python/lldbsuite/test/macosx/queues/Makefile
new file mode 100644
index 0000000..93f2f7b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/queues/Makefile
@@ -0,0 +1,28 @@
+CC ?= clang
+ifeq "$(ARCH)" ""
+	ARCH = x86_64
+endif
+
+ifeq "$(OS)" ""
+	OS = $(shell uname -s)
+endif
+
+CFLAGS ?= -g -O0
+CWD := $(shell pwd)
+
+LIB_PREFIX := lib
+
+ifeq "$(OS)" "Darwin"
+	CFLAGS += -arch $(ARCH)
+endif
+
+all: a.out
+
+a.out: main.o
+	$(CC) $(CFLAGS) -o a.out main.o
+
+main.o: main.c
+	$(CC) $(CFLAGS) -c main.c
+
+clean:
+	rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM)
diff --git a/packages/Python/lldbsuite/test/macosx/queues/TestQueues.py b/packages/Python/lldbsuite/test/macosx/queues/TestQueues.py
new file mode 100644
index 0000000..492d1d3
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/queues/TestQueues.py
@@ -0,0 +1,243 @@
+"""Test queues inspection SB APIs."""
+
+from __future__ import print_function
+
+
+
+import unittest2
+import os, time
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class TestQueues(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    @add_test_categories(['pyapi'])      
+    @unittest2.expectedFailure("rdar://22531180")
+    def test_with_python_api(self):
+        """Test queues inspection SB APIs."""
+        self.build()
+        self.queues()
+        self.queues_with_libBacktraceRecording()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line numbers that we will step to in main:
+        self.main_source = "main.c"
+
+    def check_queue_for_valid_queue_id(self, queue):
+        self.assertTrue(queue.GetQueueID() != 0, "Check queue %s for valid QueueID (got 0x%x)" % (queue.GetName(), queue.GetQueueID()))
+
+    def check_running_and_pending_items_on_queue(self, queue, expected_running, expected_pending):
+        self.assertTrue(queue.GetNumPendingItems() == expected_pending, "queue %s should have %d pending items, instead has %d pending items" % (queue.GetName(), expected_pending, (queue.GetNumPendingItems())))
+        self.assertTrue(queue.GetNumRunningItems() == expected_running, "queue %s should have %d running items, instead has %d running items" % (queue.GetName(), expected_running, (queue.GetNumRunningItems())))
+
+    def check_number_of_threads_owned_by_queue(self, queue, number_threads):
+        self.assertTrue(queue.GetNumThreads() == number_threads, "queue %s should have %d thread executing, but has %d" % (queue.GetName(), number_threads, queue.GetNumThreads()))
+
+    def check_queue_kind (self, queue, kind):
+        expected_kind_string = "Unknown"
+        if kind == lldb.eQueueKindSerial:
+            expected_kind_string = "Serial queue"
+        if kind == lldb.eQueueKindConcurrent:
+            expected_kind_string = "Concurrent queue"
+        actual_kind_string = "Unknown"
+        if queue.GetKind() == lldb.eQueueKindSerial:
+            actual_kind_string = "Serial queue"
+        if queue.GetKind() == lldb.eQueueKindConcurrent:
+            actual_kind_string = "Concurrent queue"
+        self.assertTrue(queue.GetKind() == kind, "queue %s is expected to be a %s but it is actually a %s" % (queue.GetName(), expected_kind_string, actual_kind_string))
+
+    def check_queues_threads_match_queue(self, queue):
+        for idx in range(0, queue.GetNumThreads()):
+            t = queue.GetThreadAtIndex(idx)
+            self.assertTrue(t.IsValid(), "Queue %s's thread #%d must be valid" % (queue.GetName(), idx))
+            self.assertTrue(t.GetQueueID() == queue.GetQueueID(), "Queue %s has a QueueID of %d but its thread #%d has a QueueID of %d" % (queue.GetName(), queue.GetQueueID(), idx, t.GetQueueID()))
+            self.assertTrue(t.GetQueueName() == queue.GetName(), "Queue %s has a QueueName of %s but its thread #%d has a QueueName of %s" % (queue.GetName(), queue.GetName(), idx, t.GetQueueName()))
+            self.assertTrue(t.GetQueue().GetQueueID() == queue.GetQueueID(), "Thread #%d's Queue's QueueID of %d is not the same as the QueueID of its owning queue %d" % (idx, t.GetQueue().GetQueueID(), queue.GetQueueID()))
+
+    def queues(self):
+        """Test queues inspection SB APIs without libBacktraceRecording."""
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+        self.main_source_spec = lldb.SBFileSpec (self.main_source)
+        break1 = target.BreakpointCreateByName ("stopper", 'a.out')
+        self.assertTrue(break1, VALID_BREAKPOINT)
+        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        self.assertTrue(process, PROCESS_IS_VALID)
+        threads = lldbutil.get_threads_stopped_at_breakpoint (process, break1)
+        if len(threads) != 1:
+            self.fail ("Failed to stop at breakpoint 1.")
+
+        queue_submittor_1 = lldb.SBQueue()
+        queue_performer_1 = lldb.SBQueue()
+        queue_performer_2 = lldb.SBQueue()
+        queue_performer_3 = lldb.SBQueue()
+        for idx in range (0, process.GetNumQueues()):
+          q = process.GetQueueAtIndex(idx)
+          if q.GetName() == "com.apple.work_submittor_1":
+            queue_submittor_1 = q
+          if q.GetName() == "com.apple.work_performer_1":
+            queue_performer_1 = q
+          if q.GetName() == "com.apple.work_performer_2":
+            queue_performer_2 = q
+          if q.GetName() == "com.apple.work_performer_3":
+            queue_performer_3 = q
+
+        self.assertTrue(queue_submittor_1.IsValid() and queue_performer_1.IsValid() and queue_performer_2.IsValid() and queue_performer_3.IsValid(), "Got all four expected queues: %s %s %s %s" % (queue_submittor_1.IsValid(), queue_performer_1.IsValid(), queue_performer_2.IsValid(), queue_performer_3.IsValid()))
+
+        self.check_queue_for_valid_queue_id (queue_submittor_1)
+        self.check_queue_for_valid_queue_id (queue_performer_1)
+        self.check_queue_for_valid_queue_id (queue_performer_2)
+        self.check_queue_for_valid_queue_id (queue_performer_3)
+
+        self.check_number_of_threads_owned_by_queue (queue_submittor_1, 1)
+        self.check_number_of_threads_owned_by_queue (queue_performer_1, 1)
+        self.check_number_of_threads_owned_by_queue (queue_performer_2, 1)
+        self.check_number_of_threads_owned_by_queue (queue_performer_3, 4)
+
+        self.check_queue_kind (queue_submittor_1, lldb.eQueueKindSerial)
+        self.check_queue_kind (queue_performer_1, lldb.eQueueKindSerial)
+        self.check_queue_kind (queue_performer_2, lldb.eQueueKindSerial)
+        self.check_queue_kind (queue_performer_3, lldb.eQueueKindConcurrent)
+        
+        self.check_queues_threads_match_queue (queue_submittor_1)
+        self.check_queues_threads_match_queue (queue_performer_1)
+        self.check_queues_threads_match_queue (queue_performer_2)
+        self.check_queues_threads_match_queue (queue_performer_3)
+
+
+
+        # We have threads running with all the different dispatch QoS service
+        # levels - find those threads and check that we can get the correct
+        # QoS name for each of them.
+
+        user_initiated_thread = lldb.SBThread()
+        user_interactive_thread = lldb.SBThread()
+        utility_thread = lldb.SBThread()
+        unspecified_thread = lldb.SBThread()
+        background_thread = lldb.SBThread()
+        for th in process.threads:
+            if th.GetName() == "user initiated QoS":
+                user_initiated_thread = th
+            if th.GetName() == "user interactive QoS":
+                user_interactive_thread = th
+            if th.GetName() == "utility QoS":
+                utility_thread = th
+            if th.GetName() == "unspecified QoS":
+                unspecified_thread = th
+            if th.GetName() == "background QoS":
+                background_thread = th
+
+        self.assertTrue(user_initiated_thread.IsValid(), "Found user initiated QoS thread")
+        self.assertTrue(user_interactive_thread.IsValid(), "Found user interactive QoS thread")
+        self.assertTrue(utility_thread.IsValid(), "Found utility QoS thread")
+        self.assertTrue(unspecified_thread.IsValid(), "Found unspecified QoS thread")
+        self.assertTrue(background_thread.IsValid(), "Found background QoS thread")
+
+        stream = lldb.SBStream()
+        self.assertTrue(user_initiated_thread.GetInfoItemByPathAsString("requested_qos.printable_name", stream), "Get QoS printable string for user initiated QoS thread")
+        self.assertTrue(stream.GetData() == "User Initiated", "user initiated QoS thread name is valid")
+        stream.Clear()
+        self.assertTrue(user_interactive_thread.GetInfoItemByPathAsString("requested_qos.printable_name", stream), "Get QoS printable string for user interactive QoS thread")
+        self.assertTrue(stream.GetData() == "User Interactive", "user interactive QoS thread name is valid")
+        stream.Clear()
+        self.assertTrue(utility_thread.GetInfoItemByPathAsString("requested_qos.printable_name", stream), "Get QoS printable string for utility QoS thread")
+        self.assertTrue(stream.GetData() == "Utility", "utility QoS thread name is valid")
+        stream.Clear()
+        self.assertTrue(unspecified_thread.GetInfoItemByPathAsString("requested_qos.printable_name", stream), "Get QoS printable string for unspecified QoS thread")
+        self.assertTrue(stream.GetData() == "User Initiated", "unspecified QoS thread name is valid")
+        stream.Clear()
+        self.assertTrue(background_thread.GetInfoItemByPathAsString("requested_qos.printable_name", stream), "Get QoS printable string for background QoS thread")
+        self.assertTrue(stream.GetData() == "Background", "background QoS thread name is valid")
+
+    def queues_with_libBacktraceRecording(self):
+        """Test queues inspection SB APIs with libBacktraceRecording present."""
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        if not os.path.isfile('/Applications/Xcode.app/Contents/Developer/usr/lib/libBacktraceRecording.dylib'):
+          self.skipTest ("Skipped because libBacktraceRecording.dylib was present on the system.")
+          
+        if not os.path.isfile('/usr/lib/system/introspection/libdispatch.dylib'):
+          self.skipTest ("Skipped because introspection libdispatch dylib is not present.")
+          
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        self.main_source_spec = lldb.SBFileSpec (self.main_source)
+
+        break1 = target.BreakpointCreateByName ("stopper", 'a.out')
+        self.assertTrue(break1, VALID_BREAKPOINT)
+
+        # Now launch the process, and do not stop at entry point.
+        process = target.LaunchSimple (None, ['DYLD_INSERT_LIBRARIES=/Applications/Xcode.app/Contents/Developer/usr/lib/libBacktraceRecording.dylib', 'DYLD_LIBRARY_PATH=/usr/lib/system/introspection'], self.get_process_working_directory())
+
+        self.assertTrue(process, PROCESS_IS_VALID)
+
+        # The stop reason of the thread should be breakpoint.
+        threads = lldbutil.get_threads_stopped_at_breakpoint (process, break1)
+        if len(threads) != 1:
+            self.fail ("Failed to stop at breakpoint 1.")
+
+        libbtr_module_filespec = lldb.SBFileSpec("libBacktraceRecording.dylib")
+        libbtr_module = target.FindModule (libbtr_module_filespec)
+        if not libbtr_module.IsValid():
+          self.skipTest ("Skipped because libBacktraceRecording.dylib was not loaded into the process.")
+
+        self.assertTrue(process.GetNumQueues() >= 4, "Found the correct number of queues.")
+
+        queue_submittor_1 = lldb.SBQueue()
+        queue_performer_1 = lldb.SBQueue()
+        queue_performer_2 = lldb.SBQueue()
+        queue_performer_3 = lldb.SBQueue()
+        for idx in range (0, process.GetNumQueues()):
+          q = process.GetQueueAtIndex(idx)
+          if q.GetName() == "com.apple.work_submittor_1":
+            queue_submittor_1 = q
+          if q.GetName() == "com.apple.work_performer_1":
+            queue_performer_1 = q
+          if q.GetName() == "com.apple.work_performer_2":
+            queue_performer_2 = q
+          if q.GetName() == "com.apple.work_performer_3":
+            queue_performer_3 = q
+
+        self.assertTrue(queue_submittor_1.IsValid() and queue_performer_1.IsValid() and queue_performer_2.IsValid() and queue_performer_3.IsValid(), "Got all four expected queues: %s %s %s %s" % (queue_submittor_1.IsValid(), queue_performer_1.IsValid(), queue_performer_2.IsValid(), queue_performer_3.IsValid()))
+
+        self.check_queue_for_valid_queue_id (queue_submittor_1)
+        self.check_queue_for_valid_queue_id (queue_performer_1)
+        self.check_queue_for_valid_queue_id (queue_performer_2)
+        self.check_queue_for_valid_queue_id (queue_performer_3)
+
+        self.check_running_and_pending_items_on_queue (queue_submittor_1, 1, 0)
+        self.check_running_and_pending_items_on_queue (queue_performer_1, 1, 3)
+        self.check_running_and_pending_items_on_queue (queue_performer_2, 1, 9999)
+        self.check_running_and_pending_items_on_queue (queue_performer_3, 4, 0)
+       
+        self.check_number_of_threads_owned_by_queue (queue_submittor_1, 1)
+        self.check_number_of_threads_owned_by_queue (queue_performer_1, 1)
+        self.check_number_of_threads_owned_by_queue (queue_performer_2, 1)
+        self.check_number_of_threads_owned_by_queue (queue_performer_3, 4)
+
+        self.check_queue_kind (queue_submittor_1, lldb.eQueueKindSerial)
+        self.check_queue_kind (queue_performer_1, lldb.eQueueKindSerial)
+        self.check_queue_kind (queue_performer_2, lldb.eQueueKindSerial)
+        self.check_queue_kind (queue_performer_3, lldb.eQueueKindConcurrent)
+        
+
+        self.check_queues_threads_match_queue (queue_submittor_1)
+        self.check_queues_threads_match_queue (queue_performer_1)
+        self.check_queues_threads_match_queue (queue_performer_2)
+        self.check_queues_threads_match_queue (queue_performer_3)
+
+        self.assertTrue(queue_performer_2.GetPendingItemAtIndex(0).IsValid(), "queue 2's pending item #0 is valid")
+        self.assertTrue(queue_performer_2.GetPendingItemAtIndex(0).GetAddress().GetSymbol().GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2")
+        self.assertTrue(queue_performer_2.GetNumPendingItems() == 9999, "verify that queue 2 still has 9999 pending items")
+        self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9998).IsValid(), "queue 2's pending item #9998 is valid")
+        self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9998).GetAddress().GetSymbol().GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2")
+        self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9999).IsValid() == False, "queue 2's pending item #9999 is invalid")
diff --git a/packages/Python/lldbsuite/test/macosx/queues/main.c b/packages/Python/lldbsuite/test/macosx/queues/main.c
new file mode 100644
index 0000000..fa6a3e5
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/queues/main.c
@@ -0,0 +1,133 @@
+#include <stdio.h>
+#include <unistd.h>
+#include <dispatch/dispatch.h>
+#include <pthread.h>
+
+void
+doing_the_work_1(void *in)
+{
+    while (1)
+        sleep (1);
+}
+
+void
+submit_work_1a(void *in)
+{
+    dispatch_queue_t *work_performer_1 = (dispatch_queue_t*) in;
+    dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
+    dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
+}
+
+void
+submit_work_1b(void *in)
+{
+    dispatch_queue_t *work_performer_1 = (dispatch_queue_t*) in;
+    dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
+    dispatch_async_f (*work_performer_1, NULL, doing_the_work_1);
+    while (1)
+      sleep (1);
+}
+
+void
+doing_the_work_2(void *in)
+{
+    while (1)
+        sleep (1);
+}
+
+void
+submit_work_2(void *in)
+{
+    dispatch_queue_t *work_performer_2 = (dispatch_queue_t*) in;
+    int i = 0;
+    while (i++ <  5000)
+    {
+        dispatch_async_f (*work_performer_2, NULL, doing_the_work_2);
+        dispatch_async_f (*work_performer_2, NULL, doing_the_work_2);
+    }
+}
+
+
+void
+doing_the_work_3(void *in)
+{
+    while (1)
+        sleep(1);
+}
+
+void
+submit_work_3(void *in)
+{
+    dispatch_queue_t *work_performer_3 = (dispatch_queue_t*) in;
+    dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
+    dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
+    dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
+    dispatch_async_f (*work_performer_3, NULL, doing_the_work_3);
+}
+
+
+void
+stopper ()
+{
+    while (1)
+        sleep (1);
+}
+
+int main ()
+{
+    dispatch_queue_t work_submittor_1 = dispatch_queue_create ("com.apple.work_submittor_1", DISPATCH_QUEUE_SERIAL);
+    dispatch_queue_t work_submittor_2 = dispatch_queue_create ("com.apple.work_submittor_and_quit_2", DISPATCH_QUEUE_SERIAL);
+    dispatch_queue_t work_submittor_3 = dispatch_queue_create ("com.apple.work_submittor_3", DISPATCH_QUEUE_SERIAL);
+
+    dispatch_queue_t work_performer_1 = dispatch_queue_create ("com.apple.work_performer_1", DISPATCH_QUEUE_SERIAL);
+    dispatch_queue_t work_performer_2 = dispatch_queue_create ("com.apple.work_performer_2", DISPATCH_QUEUE_SERIAL);
+
+    dispatch_queue_t work_performer_3 = dispatch_queue_create ("com.apple.work_performer_3", DISPATCH_QUEUE_CONCURRENT);
+
+    dispatch_async_f (work_submittor_1, (void*) &work_performer_1, submit_work_1a);
+    dispatch_async_f (work_submittor_1, (void*) &work_performer_1, submit_work_1b);
+
+    dispatch_async_f (work_submittor_2, (void*) &work_performer_2, submit_work_2);
+
+    dispatch_async_f (work_submittor_3, (void*) &work_performer_3, submit_work_3);
+
+
+    // Spin up threads with each of the different libdispatch QoS values.
+
+    dispatch_async (dispatch_get_global_queue(QOS_CLASS_USER_INITIATED, 0), ^{
+            pthread_setname_np ("user initiated QoS");
+            while (1)
+                sleep (10);
+                });
+    dispatch_async (dispatch_get_global_queue(QOS_CLASS_USER_INTERACTIVE, 0), ^{
+            pthread_setname_np ("user interactive QoS");
+            while (1)
+                sleep (10);
+                });
+    dispatch_async (dispatch_get_global_queue(QOS_CLASS_DEFAULT, 0), ^{
+            pthread_setname_np ("default QoS");
+            while (1)
+                sleep (10);
+                });
+    dispatch_async (dispatch_get_global_queue(QOS_CLASS_UTILITY, 0), ^{
+            pthread_setname_np ("utility QoS");
+            while (1)
+                sleep (10);
+                });
+    dispatch_async (dispatch_get_global_queue(QOS_CLASS_BACKGROUND, 0), ^{
+            pthread_setname_np ("background QoS");
+            while (1)
+                sleep (10);
+                });
+    dispatch_async (dispatch_get_global_queue(QOS_CLASS_UNSPECIFIED, 0), ^{
+            pthread_setname_np ("unspecified QoS");
+            while (1)
+                sleep (10);
+                });
+
+
+    sleep (1);
+    stopper ();
+
+}
+
diff --git a/packages/Python/lldbsuite/test/macosx/safe-to-func-call/Makefile b/packages/Python/lldbsuite/test/macosx/safe-to-func-call/Makefile
new file mode 100644
index 0000000..93f2f7b
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/safe-to-func-call/Makefile
@@ -0,0 +1,28 @@
+CC ?= clang
+ifeq "$(ARCH)" ""
+	ARCH = x86_64
+endif
+
+ifeq "$(OS)" ""
+	OS = $(shell uname -s)
+endif
+
+CFLAGS ?= -g -O0
+CWD := $(shell pwd)
+
+LIB_PREFIX := lib
+
+ifeq "$(OS)" "Darwin"
+	CFLAGS += -arch $(ARCH)
+endif
+
+all: a.out
+
+a.out: main.o
+	$(CC) $(CFLAGS) -o a.out main.o
+
+main.o: main.c
+	$(CC) $(CFLAGS) -c main.c
+
+clean:
+	rm -rf $(wildcard *.o *~ *.dylib *.so a.out *.dSYM)
diff --git a/packages/Python/lldbsuite/test/macosx/safe-to-func-call/TestSafeFuncCalls.py b/packages/Python/lldbsuite/test/macosx/safe-to-func-call/TestSafeFuncCalls.py
new file mode 100644
index 0000000..297223c
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/safe-to-func-call/TestSafeFuncCalls.py
@@ -0,0 +1,63 @@
+"""Test function call thread safety."""
+
+from __future__ import print_function
+
+
+
+import os, time
+import lldb
+import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.lldbtest import *
+
+class TestSafeFuncCalls(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line numbers that we will step to in main:
+        self.main_source = "main.c"
+
+    @skipUnlessDarwin
+    @add_test_categories(['pyapi'])
+    def test_with_python_api(self):
+        """Test function call thread safety."""
+        self.build()
+        exe = os.path.join(os.getcwd(), "a.out")
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+        self.main_source_spec = lldb.SBFileSpec (self.main_source)
+        break1 = target.BreakpointCreateByName ("stopper", 'a.out')
+        self.assertTrue(break1, VALID_BREAKPOINT)
+        process = target.LaunchSimple (None, None, self.get_process_working_directory())
+        self.assertTrue(process, PROCESS_IS_VALID)
+        threads = lldbutil.get_threads_stopped_at_breakpoint (process, break1)
+        if len(threads) != 1:
+            self.fail ("Failed to stop at breakpoint 1.")
+
+        self.check_number_of_threads(process)
+
+        main_thread = lldb.SBThread()
+        select_thread = lldb.SBThread()
+        for idx in range (0, process.GetNumThreads()):
+            t = process.GetThreadAtIndex (idx)
+            if t.GetName() == "main thread":
+                main_thread = t
+            if t.GetName() == "select thread":
+                select_thread = t
+
+        self.assertTrue(main_thread.IsValid() and select_thread.IsValid(), "Got both expected threads")
+
+        self.safe_to_call_func_on_main_thread (main_thread)
+        self.safe_to_call_func_on_select_thread (select_thread)
+
+    def check_number_of_threads(self, process):
+        self.assertTrue(process.GetNumThreads() == 2, "Check that the process has two threads when sitting at the stopper() breakpoint")
+
+    def safe_to_call_func_on_main_thread (self, main_thread):
+        self.assertTrue(main_thread.SafeToCallFunctions() == True, "It is safe to call functions on the main thread")
+
+    def safe_to_call_func_on_select_thread (self, select_thread):
+        self.assertTrue(select_thread.SafeToCallFunctions() == False, "It is not safe to call functions on the select thread")
diff --git a/packages/Python/lldbsuite/test/macosx/safe-to-func-call/main.c b/packages/Python/lldbsuite/test/macosx/safe-to-func-call/main.c
new file mode 100644
index 0000000..613384f
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/safe-to-func-call/main.c
@@ -0,0 +1,30 @@
+#include <sys/select.h>
+#include <stdio.h>
+#include <pthread.h>
+#include <unistd.h>
+
+void *
+select_thread (void *in)
+{
+    pthread_setname_np ("select thread");
+    fd_set fdset;
+    FD_SET (STDIN_FILENO, &fdset);
+    while (1)
+        select (2, &fdset, NULL, NULL, NULL);
+    return NULL;
+}
+
+void stopper ()
+{
+    while (1)
+        sleep(1); // break here
+}
+
+int main ()
+{
+    pthread_setname_np ("main thread");
+    pthread_t other_thread;
+    pthread_create (&other_thread, NULL, select_thread, NULL);
+    sleep (1);
+    stopper();
+}
diff --git a/packages/Python/lldbsuite/test/macosx/universal/Makefile b/packages/Python/lldbsuite/test/macosx/universal/Makefile
new file mode 100644
index 0000000..854c78e
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/universal/Makefile
@@ -0,0 +1,19 @@
+CC ?= clang
+
+testit: testit.i386 testit.x86_64
+	lipo -create -o testit testit.i386 testit.x86_64
+
+testit.i386: testit.i386.o
+	$(CC) -arch i386 -o testit.i386 testit.i386.o
+
+testit.x86_64: testit.x86_64.o
+	$(CC) -arch x86_64 -o testit.x86_64 testit.x86_64.o
+
+testit.i386.o: main.c
+	$(CC) -g -O0 -arch i386 -c -o testit.i386.o main.c
+
+testit.x86_64.o: main.c
+	$(CC) -g -O0 -arch x86_64 -c -o testit.x86_64.o main.c
+
+clean:
+	rm -rf $(wildcard testit* *~)
diff --git a/packages/Python/lldbsuite/test/macosx/universal/TestUniversal.py b/packages/Python/lldbsuite/test/macosx/universal/TestUniversal.py
new file mode 100644
index 0000000..4b722b0
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/universal/TestUniversal.py
@@ -0,0 +1,107 @@
+"""Test aspects of lldb commands on universal binaries."""
+
+from __future__ import print_function
+
+
+
+import unittest2
+import os, time
+import lldb
+from lldbsuite.test.lldbtest import *
+import lldbsuite.test.lldbutil as lldbutil
+
+class UniversalTestCase(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.c', '// Set break point at this line.')
+
+    @add_test_categories(['pyapi'])
+    @skipUnlessDarwin
+    @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in ['i386', 'x86_64'],
+            "requires i386 or x86_64")
+    def test_sbdebugger_create_target_with_file_and_target_triple(self):
+        """Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API."""
+        # Invoke the default build rule.
+        self.build()
+
+        # Note that "testit" is a universal binary.
+        exe = os.path.join(os.getcwd(), "testit")
+
+        # Create a target by the debugger.
+        target = self.dbg.CreateTargetWithFileAndTargetTriple(exe, "i386-apple-macosx")
+        self.assertTrue(target, VALID_TARGET)
+
+        # 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)
+
+    @skipUnlessDarwin
+    @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in ['i386', 'x86_64'],
+            "requires i386 or x86_64")
+    def test_process_launch_for_universal(self):
+        """Test process launch of a universal binary."""
+        from lldbsuite.test.lldbutil import print_registers
+
+        # Invoke the default build rule.
+        self.build()
+
+        # Note that "testit" is a universal binary.
+        exe = os.path.join(os.getcwd(), "testit")
+
+        # By default, x86_64 is assumed if no architecture is specified.
+        self.expect("file " + exe, CURRENT_EXECUTABLE_SET,
+            startstr = "Current executable set to ",
+            substrs = ["testit' (x86_64)."])
+
+        # Break inside the main.
+        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
+
+        # We should be able to launch the x86_64 executable.
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # Check whether we have a 64-bit process launched.
+        target = self.dbg.GetSelectedTarget()
+        process = target.GetProcess()
+        self.assertTrue(target and process and
+                        self.invoke(process, 'GetAddressByteSize') == 8,
+                        "64-bit process launched")
+
+        frame = process.GetThreadAtIndex(0).GetFrameAtIndex(0)
+        registers = print_registers(frame, string_buffer=True)
+        self.expect(registers, exe=False,
+            substrs = ['Name: rax'])
+
+        self.runCmd("continue")
+
+        # Now specify i386 as the architecture for "testit".
+        self.expect("file -a i386 " + exe, CURRENT_EXECUTABLE_SET,
+            startstr = "Current executable set to ",
+            substrs = ["testit' (i386)."])
+
+        # Break inside the main.
+        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, num_expected_locations=1, loc_exact=True)
+
+        # We should be able to launch the i386 executable as well.
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # Check whether we have a 32-bit process launched.
+        target = self.dbg.GetSelectedTarget()
+        process = target.GetProcess()
+        self.assertTrue(target and process,
+                        "32-bit process launched")
+
+        pointerSize = self.invoke(process, 'GetAddressByteSize')
+        self.assertTrue(pointerSize == 4,
+                        "AddressByteSize of 32-bit process should be 4, got %d instead." % pointerSize)
+
+        frame = process.GetThreadAtIndex(0).GetFrameAtIndex(0)
+        registers = print_registers(frame, string_buffer=True)
+        self.expect(registers, exe=False,
+            substrs = ['Name: eax'])
+
+        self.runCmd("continue")
diff --git a/packages/Python/lldbsuite/test/macosx/universal/main.c b/packages/Python/lldbsuite/test/macosx/universal/main.c
new file mode 100644
index 0000000..9351c77
--- /dev/null
+++ b/packages/Python/lldbsuite/test/macosx/universal/main.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+int
+main (int argc, char **argv)
+{
+  printf ("Hello there!\n"); // Set break point at this line.
+  return 0;
+}