[lldb] Skip target variable tests on Darwin because of chained fixups

[JDevlieghere]

Summary

When targeting macOS Ventura, ld64 will use authenticated fixups for x86_64 as well as arm64 (where that has always been the case). This results in 4 test failures when using an Xcode 14 toolchain on an Intel mac running macOS Ventura:

Failed Tests (4):
  lldb-api :: commands/target/basic/TestTargetCommand.py
  lldb-api :: functionalities/return-value/TestReturnValue.py
  lldb-api :: lang/c/global_variables/TestGlobalVariables.py
  lldb-api :: lang/cpp/char8_t/TestCxxChar8_t.py

Rather than trying to come up with a sophisticated decorator based off the deployment target, I marked them all as skipped with a comment explaining why.

[JDevlieghere]

With this patch applied the test suite should be clean on an Intel mac running macOS Ventura beta + Xcode 14 beta.

[jasonmolenda]

I don't know if I support bothering with checking ld's version, I think these tests should be skipped on Darwin.

Before macOS 12, if you built these tests arm64e, the address for something like my_global_str in lldb/test/API/commands/target/basic/globals.c would be the file address and an extra high bit set, a flag to dyld at runtime. As of macOS 12 and newer, on arm64 and arm64e, chained fixups are being used and now my_global_str as a file offset (not a file address) and a high bit to indicate the linker needs to fix it.

On Intel, if you use Xcode 13's ld64 and have a deployment target of macOS 13 (macOS Ventura, the one in beta right now), you'll also get chained fixups. Old linker, newer deployment target, and the tests can fail. Using the Xcode 13 ld64 on a macOS 13 system would probably get you chained fixups by default.

We already skip these tests for arm64 & arm64e because of the chained fixups and arm64e fixups before that -- and now we're going to skip them on x86_64 if the deployment target is new enough (that's the right way to do it, not the linker version) -- I say we skip them on Darwin outright. Pre-execution, we can't reliably view global variables, unless we talk with the ld64/dyld folks and see if we can reliably get the file offset out of these fields and work out the file address ourselves.

[JDevlieghere]

Check the darwin OS version as a proxy for the deployment target

[JDevlieghere]

In D131741#3717974, @jasonmolenda wrote:

We already skip these tests for arm64 & arm64e because of the chained fixups and arm64e fixups before that -- and now we're going to skip them on x86_64 if the deployment target is new enough (that's the right way to do it, not the linker version) -- I say we skip them on Darwin outright. Pre-execution, we can't reliably view global variables, unless we talk with the ld64/dyld folks and see if we can reliably get the file offset out of these fields and work out the file address ourselves.

They're XFAILed rather than skipped on Apple Silicon. We can't XFAIL them outright on Intel because the bots are running an older OS/Xcode, but you're totally right that we could skip them. I'd still like to get this working (although I'm not that motivated) once the linker folks finish upstreaming support for chained fixups in llvm. That + the fact that skipped tests bit rot much faster made me stick with XFAIL. WDYT?

[JDevlieghere]

In D131741#3717992, @JDevlieghere wrote:

In D131741#3717974, @jasonmolenda wrote:

We already skip these tests for arm64 & arm64e because of the chained fixups and arm64e fixups before that -- and now we're going to skip them on x86_64 if the deployment target is new enough (that's the right way to do it, not the linker version) -- I say we skip them on Darwin outright. Pre-execution, we can't reliably view global variables, unless we talk with the ld64/dyld folks and see if we can reliably get the file offset out of these fields and work out the file address ourselves.

They're XFAILed rather than skipped on Apple Silicon. We can't XFAIL them outright on Intel because the bots are running an older OS/Xcode, but you're totally right that we could skip them. I'd still like to get this working (although I'm not that motivated) once the linker folks finish upstreaming support for chained fixups in llvm. That + the fact that skipped tests bit rot much faster made me stick with XFAIL. WDYT?

After thinking about it some more, it's a lot easier to skip the test. When using Xcode 13.4 on Ventura, you'll still get the old behavior unless you explicitly raise the deployment target.

[jasonmolenda]

LGTM.

lldb/test/API/commands/target/basic/TestTargetCommand.py

def buildAll(self):
         self.build(dictionary=dc)
         self.addTearDownCleanup(dictionary=dc)
 
     def test_target_command(self):
         """Test some target commands: create, list, select."""
         self.buildAll()
         self.do_target_command()
 
-    @expectedFailureDarwin(archs=["arm64", "arm64e"]) # <rdar://problem/37773624>
+    @skipIfDarwin # Chained Fixups
     def test_target_variable_command(self):
         """Test 'target variable' command before and after starting the inferior."""
         d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('globals')}
         self.build(dictionary=d)
         self.addTearDownCleanup(dictionary=d)
 
         self.do_target_variable_command('globals')
 
-    @expectedFailureDarwin(archs=["arm64", "arm64e"]) # <rdar://problem/37773624>
+    @skipIfDarwin # Chained Fixups
     def test_target_variable_command_no_fail(self):
         """Test 'target variable' command before and after starting the inferior."""
         d = {'C_SOURCES': 'globals.c', 'EXE': self.getBuildArtifact('globals')}
         self.build(dictionary=d)
         self.addTearDownCleanup(dictionary=d)
 
         self.do_target_variable_command_no_fail('globals')
 

lldb/test/API/lang/c/global_variables/TestGlobalVariables.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.source = 'main.c'
         self.line = line_number(
             self.source, '// Set break point at this line.')
         self.shlib_names = ["a"]
 
+    @skipIfDarwin # Chained Fixups
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24764")
-    @expectedFailureDarwin(archs=["arm64", "arm64e"]) # <rdar://problem/37773624>
     def test_without_process(self):
         """Test that static initialized variables can be inspected without
         process."""
         self.build()
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
 

lldb/test/API/lang/cpp/char8_t/TestCxxChar8_t.py

 # coding=utf8
 """
 Test that C++ supports char8_t correctly.
 """
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 import lldbsuite.test.lldbutil as lldbutil
 
 
 class CxxChar8_tTestCase(TestBase):
 
+    @skipIfDarwin # Chained Fixups
     @skipIf(compiler="clang", compiler_version=['<', '7.0'])
-    @expectedFailureDarwin(archs=["arm64", "arm64e"]) # <rdar://problem/37773624>
     def test_without_process(self):
         """Test that C++ supports char8_t without a running process."""
         self.build()
         lldbutil.run_to_breakpoint_make_target(self)
 
         self.expect("target variable a", substrs=["char8_t", "0x61 u8'a'"])
         self.expect("target variable ab",
                 substrs=["const char8_t *", 'u8"你好"'])