vendor/lldb/lldb-trunk-r338150

1 files changed, 48 insertions, 62 deletions

diff --git a/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py b/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py
index 550eae85e1d6..611869932b61 100644
--- a/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py
+++ b/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py
@@ -29,44 +29,32 @@ class ExecTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @skipUnlessDarwin
-    @expectedFailureAll(oslist=['macosx'], bugnumber="rdar://36134350") # when building with cmake on green gragon or on ci.swift.org, this test fails.
     @expectedFailureAll(archs=['i386'], bugnumber="rdar://28656532")
     @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://problem/34559552") # this exec test has problems on ios systems
     def test_hitting_exec (self):
         self.do_test(False)
 
     @skipUnlessDarwin
-    @expectedFailureAll(oslist=['macosx'], bugnumber="rdar://36134350") # when building with cmake on green gragon or on ci.swift.org, this test fails.
     @expectedFailureAll(archs=['i386'], bugnumber="rdar://28656532")
     @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://problem/34559552") # this exec test has problems on ios systems
     def test_skipping_exec (self):
-        self.do_test(False)
+        self.do_test(True)
 
     def do_test(self, skip_exec):
-        if self.getArchitecture() == 'x86_64':
-            source = os.path.join(os.getcwd(), "main.cpp")
-            o_file = os.path.join(os.getcwd(), "main.o")
-            execute_command(
-                "'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" %
-                (os.environ["CC"], source, o_file))
-            execute_command(
-                "'%s' -g -O0 -arch i386 -arch x86_64 '%s'" %
-                (os.environ["CC"], o_file))
-            if self.debug_info != "dsym":
-                dsym_path = os.path.join(os.getcwd(), "a.out.dSYM")
-                execute_command("rm -rf '%s'" % (dsym_path))
-        else:
-            self.build()
-
-        exe = os.path.join(os.getcwd(), "a.out")
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        secondprog = self.getBuildArtifact("secondprog")
 
         # Create the target
         target = self.dbg.CreateTarget(exe)
 
         # Create any breakpoints we need
-        breakpoint = target.BreakpointCreateBySourceRegex(
+        breakpoint1 = target.BreakpointCreateBySourceRegex(
             'Set breakpoint 1 here', lldb.SBFileSpec("main.cpp", False))
-        self.assertTrue(breakpoint, VALID_BREAKPOINT)
+        self.assertTrue(breakpoint1, VALID_BREAKPOINT)
+        breakpoint2 = target.BreakpointCreateBySourceRegex(
+            'Set breakpoint 2 here', lldb.SBFileSpec("secondprog.cpp", False))
+        self.assertTrue(breakpoint2, VALID_BREAKPOINT)
 
         # Launch the process
         process = target.LaunchSimple(
@@ -74,7 +62,7 @@ class ExecTestCase(TestBase):
         self.assertTrue(process, PROCESS_IS_VALID)
 
         if skip_exec:
-            self.debugger.HandleCommand("settings set target.process.stop-on-exec false")
+            self.dbg.HandleCommand("settings set target.process.stop-on-exec false")
             def cleanup():
                 self.runCmd("settings set target.process.stop-on-exec false",
                             check=False)
@@ -82,50 +70,48 @@ class ExecTestCase(TestBase):
             # Execute the cleanup function during test case tear down.
             self.addTearDownHook(cleanup)
 
-            
-        for i in range(6):
-            # The stop reason of the thread should be breakpoint.
-            self.assertTrue(process.GetState() == lldb.eStateStopped,
-                            STOPPED_DUE_TO_BREAKPOINT)
+        # The stop reason of the thread should be breakpoint.
+        self.assertTrue(process.GetState() == lldb.eStateStopped,
+                        STOPPED_DUE_TO_BREAKPOINT)
+
+        threads = lldbutil.get_threads_stopped_at_breakpoint(
+        process, breakpoint1)
+        self.assertTrue(len(threads) == 1)
 
-            threads = lldbutil.get_threads_stopped_at_breakpoint(
-                process, breakpoint)
-            self.assertTrue(len(threads) == 1)
+        # We had a deadlock tearing down the TypeSystemMap on exec, but only if some
+        # expression had been evaluated.  So make sure we do that here so the teardown
+        # is not trivial.
 
-            # We had a deadlock tearing down the TypeSystemMap on exec, but only if some
-            # expression had been evaluated.  So make sure we do that here so the teardown
-            # is not trivial.
+        thread = threads[0]
+        value = thread.frames[0].EvaluateExpression("1 + 2")
+        self.assertTrue(
+            value.IsValid(),
+            "Expression evaluated successfully")
+        int_value = value.GetValueAsSigned()
+        self.assertTrue(int_value == 3, "Expression got the right result.")
 
-            thread = threads[0]
-            value = thread.frames[0].EvaluateExpression("1 + 2")
+        # Run and we should stop due to exec
+        process.Continue()
+
+        if not skip_exec:
+            self.assertTrue(process.GetState() == lldb.eStateStopped,
+                            "Process should be stopped at __dyld_start")
+            
+            threads = lldbutil.get_stopped_threads(
+                process, lldb.eStopReasonExec)
             self.assertTrue(
-                value.IsValid(),
-                "Expression evaluated successfully")
-            int_value = value.GetValueAsSigned()
-            self.assertTrue(int_value == 3, "Expression got the right result.")
+                len(threads) == 1,
+                "We got a thread stopped for exec.")
 
-            # Run and we should stop due to exec
+            # Run and we should stop at breakpoint in main after exec
             process.Continue()
 
-            if not skip_exec:
-                self.assertTrue(process.GetState() == lldb.eStateStopped,
-                                "Process should be stopped at __dyld_start")
-                
-                threads = lldbutil.get_stopped_threads(
-                    process, lldb.eStopReasonExec)
-                self.assertTrue(
-                    len(threads) == 1,
-                    "We got a thread stopped for exec.")
-
-                # Run and we should stop at breakpoint in main after exec
-                process.Continue()
-
-            threads = lldbutil.get_threads_stopped_at_breakpoint(
-                process, breakpoint)
-            if self.TraceOn():
-                for t in process.threads:
-                    print(t)
-                    if t.GetStopReason() != lldb.eStopReasonBreakpoint:
-                        self.runCmd("bt")
-            self.assertTrue(len(threads) == 1,
-                            "Stopped at breakpoint in exec'ed process.")
+        threads = lldbutil.get_threads_stopped_at_breakpoint(
+            process, breakpoint2)
+        if self.TraceOn():
+            for t in process.threads:
+                print(t)
+                if t.GetStopReason() != lldb.eStopReasonBreakpoint:
+                    self.runCmd("bt")
+        self.assertTrue(len(threads) == 1,
+                        "Stopped at breakpoint in exec'ed process.")