[lldb] Skip the new mte_core_file test like other MTE tests

[gribozavr]

Summary

The current exclusion is checking the LLVM backend, but it should be
checking the target platform.

[labath]

(@DavidSpickett )

I don't think this is correct, as we should be able to open the core file on non-arm machines as well. The x86 bot (https://lab.llvm.org/buildbot/#/builders/68) seems to be fine with this.

[DavidSpickett]

The windows bot is also ok with it https://lab.llvm.org/buildbot/#/builders/83/builds/21772.

What setup did you have issues on and what did the errors say?

lldb/test/API/linux/aarch64/mte_core_file/TestAArch64LinuxMTEMemoryTagCoreFile.py

class AArch64LinuxMTEMemoryTagCoreFileTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     MTE_BUF_ADDR = hex(0xffff82c74000)
     BUF_ADDR = hex(0xffff82c73000)
 
-    @skipIfLLVMTargetMissing("AArch64")
+    @skipUnlessArch("aarch64")
+    @skipUnlessPlatform(["linux"])
     def test_mte_tag_core_file_memory_region(self):
         """ Test that memory regions are marked as tagged when there is a tag
             segment in the core file. """
         self.runCmd("target create --core core.mte")
 
         # There should only be one tagged region.
         self.runCmd("memory region --all")
         got = self.res.GetOutput()
def test_mte_tag_core_file_memory_region(self):
 
         # mte_buf is tagged, buf is not.
         tagged = "memory tagging: enabled"
         self.expect("memory region {}".format(self.MTE_BUF_ADDR),
                 patterns=[tagged])
         self.expect("memory region {}".format(self.BUF_ADDR),
                 patterns=[tagged], matching=False)
 
-    @skipIfLLVMTargetMissing("AArch64")
+    @skipUnlessArch("aarch64")
+    @skipUnlessPlatform(["linux"])
     def test_mte_tag_core_file_tag_write(self):
         """ Test that "memory tag write" does not work with core files
             as they are read only. """
         self.runCmd("target create --core core.mte")
 
         self.expect("memory tag write {} 1".format(self.MTE_BUF_ADDR), error=True,
                 patterns=["error: elf-core does not support writing memory tags"])
 
-    @skipIfLLVMTargetMissing("AArch64")
+    @skipUnlessArch("aarch64")
+    @skipUnlessPlatform(["linux"])
     def test_mte_tag_core_file_tag_read(self):
         """ Test that "memory tag read" works with core files."""
         self.runCmd("target create --core core.mte")
 
         # Tags are packed 2 per byte meaning that in addition to granule alignment
         # there is also 2 x granule alignment going on.
 
         # All input validation should work as normal.
def test_mte_tag_core_file_tag_read(self):
         self.expect("memory tag read {addr} {addr}+33".format(
                 addr=self.MTE_BUF_ADDR),
                 patterns=[
                     "Allocation tags:\n"
                     "\[0x[A-Fa-f0-9]+00, 0x[A-Fa-f0-9]+10\): 0x0\n"
                     "\[0x[A-Fa-f0-9]+10, 0x[A-Fa-f0-9]+20\): 0x1 \(mismatch\)\n",
                     "\[0x[A-Fa-f0-9]+20, 0x[A-Fa-f0-9]+30\): 0x2 \(mismatch\)$"])
 
-    @skipIfLLVMTargetMissing("AArch64")
+    @skipUnlessArch("aarch64")
+    @skipUnlessPlatform(["linux"])
     def test_mte_commands_no_mte(self):
         """ Test that memory tagging commands fail on an AArch64 corefile without
             any tag segments."""
 
         self.runCmd("target create --core core.nomte")
 
         self.expect("memory tag read 0 1",
                 substrs=["error: Process does not support memory tagging"], error=True)
         # Note that this tells you memory tagging is not supported at all, versus
         # the MTE core file which does support it but does not allow writing tags.
         self.expect("memory tag write 0 1",
                 substrs=["error: Process does not support memory tagging"], error=True)