Run address expression argument values through ABI::FixCodeAddress to strip TBI/pointer auth bytes on AArch64

[jasonmolenda]

Summary

This is a different way of accomplishing the phab @DavidSpickett put up a few months ago, https://reviews.llvm.org/D136938 , which cleared these bits specifically for breakpoints in Target::GetBreakableLoadAddress.

I don't have an actual test case for this; this phabracator includes a test, but it actually won't run and I'm undecided about committing it (@JDevlieghere thinks landing a test that can't run any time soon is a bad idea). The llvm.org clang doesn't support generating the (not yet finalized) arm64e ABI on Darwin systems (ARMv8.3+ using a ptrauth ABI), although it can be forced to output a non-ptrauth codegen in an arm64e mach-o file. Even if the in-tree llvm.org clang could generate correct arm64e binaries, macOS won't allow you to run them without setting a boot-arg (-arm64e_preview_abi) on the test system & rebooting for it to be enabled. I included the test case in this phabracator to show an example of how it could be tested if these things weren't true. :)

[DavidSpickett]

I am looking at this, just taking some time to get a PAC enabled environment going again. At first glance it seems like a better way to do things. I just want to run the test from my patch against this one.

I can port the test to AArch64 Linux though that's not much closer to being run on a bot either. At least these tests are pretty simple, less likely to rot in the meantime.
(we could do with a "qemu-system-aarch64 max features" bot but unlikely I'll have time to set one up)

[JDevlieghere]

Someday I'd like to have a decorator that's a bit smarter and allows us to run these tests if the test compiler has ptrauth/PAC support and the host can run it. At least then these tests would automatically run for us (and maybe you) downstream. But with the current state of things this is as good as it gets.

lldb/source/Interpreter/OptionArgParser.cpp

161–162

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

class Base(unittest2.TestCase):
 
     def isAArch64SVE(self):
         return self.isAArch64() and "sve" in self.getCPUInfo()
 
     def isAArch64MTE(self):
         return self.isAArch64() and "mte" in self.getCPUInfo()
 
     def isAArch64PAuth(self):
+        if self.getArchitecture() == "arm64e":
+            return True
         return self.isAArch64() and "paca" in self.getCPUInfo()
 
     def getArchitecture(self):
         """Returns the architecture in effect the test suite is running with."""
         module = builder_module()
         arch = module.getArchitecture()
         if arch == 'amd64':
             arch = 'x86_64'

lldb/source/Interpreter/OptionArgParser.cpp

 //===-- OptionArgParser.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/DataFormatters/FormatManager.h"
+#include "lldb/Target/ABI.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 bool OptionArgParser::ToBoolean(llvm::StringRef ref, bool fail_value,
lldb::addr_t OptionArgParser::ToAddress(const ExecutionContext *exe_ctx,
   }
 
   llvm::StringRef sref = s;
 
   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
   if (!s.getAsInteger(0, addr)) {
     if (error_ptr)
       error_ptr->Clear();
+    Process *process = exe_ctx->GetProcessPtr();
+    if (process)
+      if (ABISP abi_sp = process->GetABI())
+        addr = abi_sp->FixCodeAddress(addr);
     return addr;
   }
 
   // Try base 16 with no prefix...
   if (!s.getAsInteger(16, addr)) {
     if (error_ptr)
       error_ptr->Clear();
     return addr;

lldb/test/API/macosx/ptrauth-address-expressions/Makefile

+C_SOURCES := main.c
+
+include Makefile.rules

lldb/test/API/macosx/ptrauth-address-expressions/TestPtrauthAddressExpressions.py

+"""Test that AArch64 PAC bits are stripped from address expression arguments"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class TestPtrauthAddressExpressions(TestBase):
+
+    NO_DEBUG_INFO_TESTCASE = True
+
+    # On Darwin systems, arch arm64e means ARMv8.3 with ptrauth
+    # ABI used.
+    @skipIf(archs=no_match(['arm64e']))
+
+    def test(self):
+
+        # Skip this test if not running on AArch64 target that supports PAC
+        if not self.isAArch64PAuth():
+            self.skipTest('Target must support pointer authentication.')
+        self.source = 'main.c'
+        self.build()
+        (self.target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
+                           "break here", lldb.SBFileSpec(self.source, False))
+
+        self.expect("p fptr", substrs=[self.source])
+        self.expect("ima loo -va fptr", substrs=[self.source])
+        self.expect("break set -a fptr", substrs=[self.source])

lldb/test/API/macosx/ptrauth-address-expressions/main.c

+#include <stdio.h>
+
+int foo () { return 10; }
+
+int main () 
+{
+  int (*fptr)() = foo;
+  printf ("%p\n", fptr); // break here
+  return fptr();
+}