Implement SoftPointerAuth prototype. (deprecated)

ahmedbougacha · dtapuska · commit 62f16ef66d6e · 2025-04-10T11:36:26.000-04:00
diff --git a/clang/include/clang/Basic/LangOptions.def b/clang/include/clang/Basic/LangOptions.def
@@ -188,6 +188,8 @@ VALUE_LANGOPT(PointerAuthABIVersion, 32, 0, "pointer authentication ABI version"
 LANGOPT(PointerAuthKernelABIVersion, 1, 0, "controls whether the pointer auth abi version represents a kernel ABI")
 LANGOPT(PointerAuthABIVersionEncoded, 1, 0, "controls whether the pointer auth abi version should be encoded in the IR")
 
+LANGOPT(SoftPointerAuth   , 1, 0, "software emulation of pointer authentication")
+
 LANGOPT(DoubleSquareBracketAttributes, 1, 0, "'[[]]' attributes extension for all language standard modes")
 LANGOPT(ExperimentalLateParseAttributes, 1, 0, "experimental late parsing of attributes")
 
diff --git a/clang/include/clang/Basic/PointerAuthOptions.h b/clang/include/clang/Basic/PointerAuthOptions.h
@@ -54,9 +54,25 @@ class PointerAuthSchema {
 public:
   enum class Kind : unsigned {
     None,
+    Soft,
     ARM8_3,
   };
 
+  /// Software pointer-signing "keys". If you add a new key, make sure this->Key
+  /// has a large enough bit-width.
+  enum class SoftKey : unsigned {
+    FunctionPointers = 0,
+    BlockInvocationFunctionPointers = 1,
+    BlockHelperFunctionPointers = 2,
+    ObjCMethodListFunctionPointers = 3,
+    CXXVTablePointers = 4,
+    CXXVirtualFunctionPointers = 5,
+    CXXMemberFunctionPointers = 6,
+    ObjCMethodListPointer = 7,
+    ObjCIsaPointer = 8,
+    BlockDescriptorPointers = 9,
+  };
+
   /// Hardware pointer-signing keys in ARM8.3.
   ///
   /// These values are the same used in ptrauth.h.
@@ -113,6 +129,24 @@ class PointerAuthSchema {
       ConstantDiscriminator = *ConstantDiscriminatorOrNone;
   }
 
+  PointerAuthSchema(
+      SoftKey Key, bool IsAddressDiscriminated,
+      PointerAuthenticationMode AuthenticationMode,
+      Discrimination OtherDiscrimination,
+      std::optional<uint16_t> ConstantDiscriminatorOrNone = std::nullopt,
+      bool IsIsaPointer = false, bool AuthenticatesNullValues = false)
+      : TheKind(Kind::Soft), IsAddressDiscriminated(IsAddressDiscriminated),
+        IsIsaPointer(IsIsaPointer),
+        AuthenticatesNullValues(AuthenticatesNullValues),
+        SelectedAuthenticationMode(AuthenticationMode),
+        DiscriminationKind(OtherDiscrimination), Key(unsigned(Key)) {
+    assert((getOtherDiscrimination() != Discrimination::Constant ||
+            ConstantDiscriminatorOrNone) &&
+           "constant discrimination requires a constant!");
+    if (ConstantDiscriminatorOrNone)
+      ConstantDiscriminator = *ConstantDiscriminatorOrNone;
+  }
+
   PointerAuthSchema(
       ARM8_3Key Key, bool IsAddressDiscriminated,
       Discrimination OtherDiscrimination,
@@ -123,6 +157,16 @@ class PointerAuthSchema {
                           OtherDiscrimination, ConstantDiscriminatorOrNone,
                           IsIsaPointer, AuthenticatesNullValues) {}
 
+  PointerAuthSchema(
+      SoftKey Key, bool IsAddressDiscriminated,
+      Discrimination OtherDiscrimination,
+      std::optional<uint16_t> ConstantDiscriminatorOrNone = std::nullopt,
+      bool IsIsaPointer = false, bool AuthenticatesNullValues = false)
+      : PointerAuthSchema(Key, IsAddressDiscriminated,
+                          PointerAuthenticationMode::SignAndAuth,
+                          OtherDiscrimination, ConstantDiscriminatorOrNone,
+                          IsIsaPointer, AuthenticatesNullValues) {}
+
   Kind getKind() const { return TheKind; }
 
   explicit operator bool() const { return isEnabled(); }
@@ -162,6 +206,8 @@ class PointerAuthSchema {
     switch (getKind()) {
     case Kind::None:
       llvm_unreachable("calling getKey() on disabled schema");
+    case Kind::Soft:
+      return unsigned(getSoftKey());
     case Kind::ARM8_3:
       return llvm::to_underlying(getARM8_3Key());
     }
@@ -172,6 +218,11 @@ class PointerAuthSchema {
     return SelectedAuthenticationMode;
   }
 
+  SoftKey getSoftKey() const {
+    assert(getKind() == Kind::Soft);
+    return SoftKey(Key);
+  }
+
   ARM8_3Key getARM8_3Key() const {
     assert(getKind() == Kind::ARM8_3);
     return ARM8_3Key(Key);
diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td
@@ -4403,6 +4403,11 @@ let Group = f_Group in {
     HelpText<"Enable Pointer Authentication kernel ABI version">;
   def fno_ptrauth_kernel_abi_version : Flag<["-"], "fno-ptrauth-kernel-abi-version">,
     HelpText<"Disable Pointer Authentication kernel ABI versioning">;
+
+  def fptrauth_soft : Flag<["-"], "fptrauth-soft">,
+      Visibility<[ClangOption, CC1Option, CC1AsOption]>,
+      HelpText<"Enable software lowering of pointer authentication">;
+  def fno_ptrauth_soft : Flag<["-"], "fno-ptrauth-soft">;
 }
 
 def fenable_matrix : Flag<["-"], "fenable-matrix">, Group<f_Group>,
diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp
@@ -77,6 +77,7 @@
 #include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
 #include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
 #include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
+#include "llvm/Transforms/Instrumentation/SoftPointerAuth.h"
 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
 #include "llvm/Transforms/Instrumentation/TypeSanitizer.h"
 #include "llvm/Transforms/ObjCARC.h"
@@ -1074,6 +1075,11 @@ void EmitAssemblyHelper::RunOptimizationPipeline(
       addKCFIPass(TargetTriple, LangOpts, PB);
     }
 
+    if (LangOpts.SoftPointerAuth)
+      PB.registerOptimizerLastEPCallback(
+          [](ModulePassManager &MPM, OptimizationLevel Level,
+             ThinOrFullLTOPhase) { MPM.addPass(SoftPointerAuthPass()); });
+
     if (std::optional<GCOVOptions> Options =
             getGCOVOptions(CodeGenOpts, LangOpts))
       PB.registerPipelineStartEPCallback(
diff --git a/clang/lib/CodeGen/CGPointerAuth.cpp b/clang/lib/CodeGen/CGPointerAuth.cpp
@@ -714,12 +714,16 @@ CodeGenModule::computeVTPointerAuthentication(const CXXRecordDecl *ThisClass) {
       return std::nullopt;
 
     if (ExplicitKey != VTablePointerAuthenticationAttr::DefaultKey) {
-      if (ExplicitKey == VTablePointerAuthenticationAttr::ProcessIndependent)
-        Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDA;
-      else {
-        assert(ExplicitKey ==
-               VTablePointerAuthenticationAttr::ProcessDependent);
-        Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDB;
+      if (Context.getLangOpts().SoftPointerAuth) {
+        Key = (unsigned)PointerAuthSchema::SoftKey::CXXVirtualFunctionPointers;
+      } else {
+        if (ExplicitKey == VTablePointerAuthenticationAttr::ProcessIndependent)
+          Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDA;
+        else {
+          assert(ExplicitKey ==
+                 VTablePointerAuthenticationAttr::ProcessDependent);
+          Key = (unsigned)PointerAuthSchema::ARM8_3Key::ASDB;
+        }
       }
     }
 
diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp
@@ -7571,6 +7571,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA,
   // -fno-common is the default, set -fcommon only when that flag is set.
   Args.addOptInFlag(CmdArgs, options::OPT_fcommon, options::OPT_fno_common);
 
+  if (Args.hasFlag(options::OPT_fptrauth_soft,
+                   options::OPT_fno_ptrauth_soft, false))
+    CmdArgs.push_back("-fptrauth-soft");
+
   // -fsigned-bitfields is default, and clang doesn't yet support
   // -funsigned-bitfields.
   if (!Args.hasFlag(options::OPT_fsigned_bitfields,
diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp
@@ -1524,6 +1524,66 @@ static void setPGOUseInstrumentor(CodeGenOptions &Opts,
 void CompilerInvocation::setDefaultPointerAuthOptions(
     PointerAuthOptions &Opts, const LangOptions &LangOpts,
     const llvm::Triple &Triple) {
+
+  if (LangOpts.SoftPointerAuth) {
+    if (LangOpts.PointerAuthCalls) {
+      using Key = PointerAuthSchema::SoftKey;
+      using Discrimination = PointerAuthSchema::Discrimination;
+      Opts.FunctionPointers =
+          PointerAuthSchema(Key::FunctionPointers, false,
+                            LangOpts.PointerAuthFunctionTypeDiscrimination
+                                ? Discrimination::Type
+                                : Discrimination::None);
+
+      Opts.CXXVTablePointers = PointerAuthSchema(
+          Key::CXXVTablePointers,
+          LangOpts.PointerAuthVTPtrAddressDiscrimination,
+          LangOpts.PointerAuthVTPtrTypeDiscrimination ? Discrimination::Type
+                                                      : Discrimination::None);
+      Opts.CXXTypeInfoVTablePointer = PointerAuthSchema(
+          Key::CXXVTablePointers, false, Discrimination::None);
+      Opts.CXXVTTVTablePointers = PointerAuthSchema(
+          Key::CXXVTablePointers, false, Discrimination::None);
+      Opts.CXXVirtualFunctionPointers =
+          Opts.CXXVirtualVariadicFunctionPointers = PointerAuthSchema(
+              Key::CXXVirtualFunctionPointers, true, Discrimination::Decl);
+      Opts.CXXMemberFunctionPointers = PointerAuthSchema(
+          Key::CXXMemberFunctionPointers, false, Discrimination::Type);
+
+      Opts.BlockInvocationFunctionPointers = PointerAuthSchema(
+          Key::BlockInvocationFunctionPointers, true, Discrimination::None);
+      Opts.BlockHelperFunctionPointers = PointerAuthSchema(
+          Key::BlockHelperFunctionPointers, true, Discrimination::None);
+      Opts.BlockByrefHelperFunctionPointers = PointerAuthSchema(
+          Key::BlockHelperFunctionPointers, true, Discrimination::None);
+      if (LangOpts.PointerAuthBlockDescriptorPointers)
+        Opts.BlockDescriptorPointers = PointerAuthSchema(
+            Key::BlockDescriptorPointers, true, Discrimination::Constant,
+            BlockDescriptorConstantDiscriminator);
+
+      Opts.ObjCMethodListFunctionPointers = PointerAuthSchema(
+          Key::ObjCMethodListFunctionPointers, true, Discrimination::None);
+      Opts.ObjCMethodListPointer = PointerAuthSchema(
+          Key::ObjCMethodListPointer, true, Discrimination::Constant,
+          MethodListPointerConstantDiscriminator);
+
+      auto IsaAuthenticationMode =
+          LangOpts.getPointerAuthObjcIsaAuthentication();
+      if (IsaAuthenticationMode != PointerAuthenticationMode::None) {
+        Opts.ObjCIsaPointers = PointerAuthSchema(
+            Key::ObjCIsaPointer, true, IsaAuthenticationMode,
+            Discrimination::Constant, IsaPointerConstantDiscriminator, true);
+        Opts.ObjCSuperPointers = PointerAuthSchema(
+            Key::ObjCIsaPointer, true, IsaAuthenticationMode,
+            Discrimination::Constant, SuperPointerConstantDiscriminator);
+      }
+    }
+    Opts.ReturnAddresses = LangOpts.PointerAuthReturns;
+    Opts.IndirectGotos = LangOpts.PointerAuthIndirectGotos;
+    Opts.AuthTraps = LangOpts.PointerAuthAuthTraps;
+    return;
+  }
+
   assert(Triple.getArch() == llvm::Triple::aarch64);
   if (LangOpts.PointerAuthCalls) {
     using Key = PointerAuthSchema::ARM8_3Key;
@@ -3558,6 +3618,8 @@ static void GeneratePointerAuthArgs(const LangOptions &Opts,
     GenerateArg(Consumer, OPT_fptrauth_type_info_vtable_pointer_discrimination);
   if (Opts.PointerAuthFunctionTypeDiscrimination)
     GenerateArg(Consumer, OPT_fptrauth_function_pointer_type_discrimination);
+  if (Opts.SoftPointerAuth)
+    GenerateArg(Consumer, OPT_fptrauth_soft);
   if (Opts.PointerAuthBlockDescriptorPointers)
     GenerateArg(Consumer, OPT_fptrauth_block_descriptor_pointers);
 
@@ -3650,6 +3712,8 @@ static void ParsePointerAuthArgs(LangOptions &Opts, ArgList &Args,
   Opts.PointerAuthABIVersion =
       getLastArgIntValue(Args, OPT_fptrauth_abi_version_EQ, 0, Diags);
   Opts.PointerAuthKernelABIVersion = Args.hasArg(OPT_fptrauth_kernel_abi_version);
+
+  Opts.SoftPointerAuth = Args.hasArg(OPT_fptrauth_soft);
 }
 
 /// Check if input file kind and language standard are compatible.
diff --git a/clang/test/Driver/arch-arm64e.c b/clang/test/Driver/arch-arm64e.c
@@ -8,6 +8,7 @@
 // NONE-NOT: "-fptrauth-indirect-gotos"
 // NONE-NOT: "-fptrauth-auth-traps"
 // NONE-NOT: "-mbranch-target-enforce"
+// NONE-NOT: "-fptrauth-soft"
 
 // RUN: %clang -target arm64-apple-ios15 -fptrauth-calls -c %s -### 2>&1 | FileCheck %s --check-prefix CALL
 // CALL: "-cc1"{{.*}} {{.*}} "-fptrauth-calls"
@@ -27,6 +28,9 @@
 // RUN: %clang -target arm64-apple-ios15 -fbranch-target-identification -c %s -### 2>&1 | FileCheck %s --check-prefix BTI
 // BTI: "-cc1"{{.*}} {{.*}} "-mbranch-target-enforce"
 
+// RUN: %clang -target arm64-apple-ios -fptrauth-soft -c %s -### 2>&1 | FileCheck %s --check-prefix SOFT
+// SOFT: "-cc1"{{.*}} {{.*}} "-fptrauth-soft"
+
 
 // Check the arm64e defaults.
 // isa signing depends on the target OS and is tested elsewhere.
diff --git a/llvm/include/llvm/InitializePasses.h b/llvm/include/llvm/InitializePasses.h
@@ -287,6 +287,7 @@ void initializeSingleLoopExtractorPass(PassRegistry &);
 void initializeSinkingLegacyPassPass(PassRegistry &);
 void initializeSjLjEHPreparePass(PassRegistry &);
 void initializeSlotIndexesWrapperPassPass(PassRegistry &);
+void initializeSoftPointerAuthLegacyPassPass(PassRegistry&);
 void initializeSpeculativeExecutionLegacyPassPass(PassRegistry &);
 void initializeSpillPlacementWrapperLegacyPass(PassRegistry &);
 void initializeStackColoringLegacyPass(PassRegistry &);
diff --git a/llvm/include/llvm/Transforms/Instrumentation/SoftPointerAuth.h b/llvm/include/llvm/Transforms/Instrumentation/SoftPointerAuth.h
@@ -0,0 +1,22 @@
+//===- SoftPointerAuth.h - Software lowering of ptrauth intrins -*- C++ -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_TRANSFORMS_INSTRUMENTATION_SOFTPOINTERAUTH_H
+#define LLVM_TRANSFORMS_INSTRUMENTATION_SOFTPOINTERAUTH_H
+
+#include "llvm/IR/PassManager.h"
+
+namespace llvm {
+
+struct SoftPointerAuthPass : public PassInfoMixin<SoftPointerAuthPass> {
+  PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_TRANSFORMS_INSTRUMENTATION_SOFTPOINTERAUTH_H
diff --git a/llvm/lib/Passes/PassBuilder.cpp b/llvm/lib/Passes/PassBuilder.cpp
@@ -246,6 +246,7 @@
 #include "llvm/Transforms/Instrumentation/RealtimeSanitizer.h"
 #include "llvm/Transforms/Instrumentation/SanitizerBinaryMetadata.h"
 #include "llvm/Transforms/Instrumentation/SanitizerCoverage.h"
+#include "llvm/Transforms/Instrumentation/SoftPointerAuth.h"
 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
 #include "llvm/Transforms/Instrumentation/TypeSanitizer.h"
 #include "llvm/Transforms/ObjCARC.h"
diff --git a/llvm/lib/Passes/PassRegistry.def b/llvm/lib/Passes/PassRegistry.def
@@ -150,6 +150,7 @@ MODULE_PASS("scc-oz-module-inliner",
 MODULE_PASS("shadow-stack-gc-lowering", ShadowStackGCLoweringPass())
 MODULE_PASS("strip", StripSymbolsPass())
 MODULE_PASS("strip-dead-debug-info", StripDeadDebugInfoPass())
+MODULE_PASS("soft-ptrauth", SoftPointerAuthPass())
 MODULE_PASS("strip-dead-prototypes", StripDeadPrototypesPass())
 MODULE_PASS("strip-debug-declare", StripDebugDeclarePass())
 MODULE_PASS("strip-nondebug", StripNonDebugSymbolsPass())
diff --git a/llvm/lib/Transforms/Instrumentation/CMakeLists.txt b/llvm/lib/Transforms/Instrumentation/CMakeLists.txt
@@ -20,6 +20,7 @@ add_llvm_component_library(LLVMInstrumentation
   PGOMemOPSizeOpt.cpp
   SanitizerCoverage.cpp
   SanitizerBinaryMetadata.cpp
+  SoftPointerAuth.cpp
   ValueProfileCollector.cpp
   ThreadSanitizer.cpp
   TypeSanitizer.cpp
diff --git a/llvm/lib/Transforms/Instrumentation/SoftPointerAuth.cpp b/llvm/lib/Transforms/Instrumentation/SoftPointerAuth.cpp
diff --git a/llvm/test/Transforms/SoftPointerAuth/intrinsics.ll b/llvm/test/Transforms/SoftPointerAuth/intrinsics.ll
diff --git a/llvm/test/Transforms/SoftPointerAuth/relocs.ll b/llvm/test/Transforms/SoftPointerAuth/relocs.ll
