[lldb][AArch64] Simplify MTE memory region test

[DavidSpickett]

Summary

By checking for cpu and toolchain features ahead
of time we don't need the custom return codes.

[DavidSpickett]

Pulling in compiler predicate from https://reviews.llvm.org/D95601
to get this landed before I attempt to fix the race condition
in hasLinuxVmFlags.

[DavidSpickett]

Going to commit this with the compiler predicate since this was accepted already and Omair has reviewed the test predicate in the other review.

lldb/packages/Python/lldbsuite/test/decorators.py

def is_compiler_with_address_sanitizer(self):
             return "Compiler cannot compile with -fsanitize=address"
         return None
     return skipTestIfFn(is_compiler_with_address_sanitizer)(func)
 
 def skipIfAsan(func):
     """Skip this test if the environment is set up to run LLDB *itself* under ASAN."""
     return skipTestIfFn(is_running_under_asan)(func)
 
+def skipUnlessAArch64MTELinuxCompiler(func):
+    """Decorate the item to skip test unless MTE is supported by the test compiler."""
+
+    def is_toolchain_with_mte(self):
+        compiler_path = self.getCompiler()
+        compiler = os.path.basename(compiler_path)
+        f = tempfile.NamedTemporaryFile()
+        if lldbplatformutil.getPlatform() == 'windows':
+            return "MTE tests are not compatible with 'windows'"
+
+        cmd = "echo 'int main() {}' | %s -x c -o %s -" % (compiler_path, f.name)
+        if os.popen(cmd).close() is not None:
+            # Cannot compile at all, don't skip the test
+            # so that we report the broken compiler normally.
+            return None
+
+        # We need the Linux headers and ACLE MTE intrinsics
+        test_src = """
+            #include <asm/hwcap.h>
+            #include <arm_acle.h>
+            #ifndef HWCAP2_MTE
+            #error
+            #endif
+            int main() {
+                void* ptr = __arm_mte_create_random_tag((void*)(0), 0);
+            }"""
+        cmd = "echo '%s' | %s -march=armv8.5-a+memtag -x c -o %s -" % (test_src, compiler_path, f.name)
+        if os.popen(cmd).close() is not None:
+            return "Toolchain does not support MTE"
+        return None
+
+    return skipTestIfFn(is_toolchain_with_mte)(func)
+
 def _get_bool_config(key, fail_value = True):
     """
     Returns the current LLDB's build config value.
     :param key The key to lookup in LLDB's build configuration.
     :param fail_value The error value to return when the key can't be found.
            Defaults to true so that if an unknown key is lookup up we rather
            enable more tests (that then fail) than silently skipping them.
     """

lldb/test/API/linux/aarch64/mte_memory_region/TestAArch64LinuxMTEMemoryRegion.py

 
 
 class AArch64LinuxMTEMemoryRegionTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
-    @skipIf(archs=no_match(["aarch64"]))
+    @skipUnlessArch("aarch64")
     @skipUnlessPlatform(["linux"])
+    @skipUnlessAArch64MTELinuxCompiler
     def test_mte_regions(self):
         if not self.isAArch64MTE():
             self.skipTest('Target must support MTE.')
         if not self.hasLinuxVmFlags():
             self.skipTest('/proc/{pid}/smaps VmFlags must be present')
 
         self.build()
         self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line(self, "main.c",
             line_number('main.c', '// Set break point at this line.'),
             num_expected_locations=1)
 
         self.runCmd("run", RUN_SUCCEEDED)
 
         if self.process().GetState() == lldb.eStateExited:
-            # 47 = non MTE toolchain
-            # 48 = non MTE target
-            exit_status = self.process().GetExitStatus()
-            if exit_status == 47:
-                self.skipTest("MTE must be available in toolchain")
-            elif exit_status == 48:
-                self.skipTest("target must have MTE enabled")
-
-            # Otherwise we have MTE but another problem occured
             self.fail("Test program failed to run.")
 
         self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
             substrs=['stopped',
                      'stop reason = breakpoint'])
 
         substrs = ["memory tagging: enabled"]
         # The new page will be tagged
         self.expect("memory region the_page", substrs=substrs)
         # Code page will not be
         self.expect("memory region main", substrs=substrs, matching=False)

lldb/test/API/linux/aarch64/mte_memory_region/main.c

 #include <asm/hwcap.h>
 #include <asm/mman.h>
 #include <sys/auxv.h>
 #include <sys/mman.h>
 #include <sys/prctl.h>
 #include <unistd.h>
 
-#define INCOMPATIBLE_TOOLCHAIN 47
-#define INCOMPATIBLE_TARGET 48
-
-// This is in a seperate non static function
-// so that we can always breakpoint the return 0 here.
-// Even if main never reaches it because HWCAP2_MTE
-// is not defined.
-// If it were in main then you would effectively have:
-// return TEST_INCOMPATIBLE;
-// return 0;
-// So the two returns would have the same breakpoint location
-// and we couldn't tell them apart.
-int setup_mte_page(void) {
-#ifdef HWCAP2_MTE
+int main(int argc, char const *argv[]) {
   if (!(getauxval(AT_HWCAP2) & HWCAP2_MTE))
-    return INCOMPATIBLE_TARGET;
+    return 1;
 
   int got = prctl(PR_SET_TAGGED_ADDR_CTRL, PR_TAGGED_ADDR_ENABLE, 0, 0, 0);
   if (got)
     return 1;
 
   void *the_page = mmap(0, sysconf(_SC_PAGESIZE), PROT_MTE,
                         MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
   if (the_page == MAP_FAILED)
     return 1;
-#endif
 
   return 0; // Set break point at this line.
 }
-
-int main(int argc, char const *argv[]) {
-#ifdef HWCAP2_MTE
-  return setup_mte_page();
-#else
-  return INCOMPATIBLE_TOOLCHAIN;
-#endif
-}