[BoundsSafety] Improve the soft trap call interface to reduce codesize impact

This patch makes several changes motivated to reduce the code size
impact at call sites to runtime functions.

* `__bounds_safety_soft_trap_c` function no longer takes an integer argument and
  has been renamed to remove the `_c` suffix. The corresponding
  `call-with-code` option to `-fbounds-safety-soft-traps=` has been
  renamed to `call-minimal`. We can reduce codeisze by avoiding writing
  constants into the `x0` on arm64 which saves us 1 instruction (4
  bytes) per call. The original motivation for passing an integer code
  was to aid debugging in the scenario where debug info is missing.
  This scenario isn't the primary use case and codesize is far more
  important so removing the argument seems like the better design
  choice.

* The runtime functions now use the `preserve_all` calling convention
  on x86_64 and arm64. This calling convention means that some registers
  that are normally caller-saved become callee-saved. This means that
  these registers do not need to be spilled at callsites which should
  reduce some code size overhead. This isn't the perfect calling
  convention because the argument passing registers could also be made
  callee saved currently aren't but such a calling convention isn't
  currently implemented in LLVM so this is the best we can do for now.
  A hidden flag (`-bounds-safety-soft-trap-preserve-all-cc=false`) to
  turn off this behavior is included. It is primarly there to make it
  easy to measure the codesize impact without having to rebuild the
  compiler.

Note: While this is an ABI breaking change
`__CLANG_BOUNDS_SAFETY_SOFT_TRAP_API_VERSION` has not been bumped
because there are currently aren't any adopters of the soft trap mode
yet.

rdar://164341162
(cherry picked from commit 4455ec3)

Conflicts:
	clang/test/BoundsSafety/CodeGen/soft-traps/call_minimal.c
	clang/test/BoundsSafety/CodeGen/soft-traps/call_minimal_custom_func.c
	clang/test/BoundsSafety/CodeGen/soft-traps/call_minimal_with_ubsan.c
	clang/test/BoundsSafety/CodeGen/soft-traps/call_with_str.c
	clang/test/BoundsSafety/CodeGen/soft-traps/call_with_str_custom_func.c
	clang/test/BoundsSafety/CodeGen/soft-traps/call_with_str_with_ubsan.c

Author: delcypher

clang/include/clang/Basic/CodeGenOptions.h

@@ -194,14 +194,15 @@ class CodeGenOptions : public CodeGenOptionsBase {
     SoftCallWithTrapString, ///< Emit a non-fatal call. The call
                             ///< is passed a string description of the failed
                             ///< bounds check.
-    SoftCallWithTrapCode,   ///< Emit a non-fatal call. The call
-                            ///< is passed an integer describing the failed
-                            ///< bounds check.
+    SoftCallMinimal,        ///< Emit a non-fatal call. The call
+                            ///< has no arguments. The reason for trapping is
+                            ///< intended to be inferred from the trap reason
+                            ///< being embedded in the debug info.
   };
 
   /// The name of the function to call for BoundsSafety soft traps. This is used
   /// with `BoundsSafetyTrapModeKind::SoftCallWithTrapString` and
-  // `BoundsSafetyTrapModeKind::SoftCallWithTrapCode`.
+  // `BoundsSafetyTrapModeKind::SoftCallMinimal`.
   std::string BoundsSafetySoftTrapFuncName;
 
   /* TO_UPSTREAM(BoundsSafety) OFF*/

clang/include/clang/Driver/Options.td

@@ -2065,17 +2065,18 @@ def fbounds_safety_soft_traps_EQ
     HelpText<"Enables soft traps which causes the compiler to emit a non-fatal "
       "instruction sequence when a bounds check fails. After this instruction "
       "sequence execution resumes as if the bounds check had succeeded."
-      "For `call-with-*` modes see 'bounds_safety_soft_traps.h' for the runtime"
+      "For `call-*` modes see 'bounds_safety_soft_traps.h' for the runtime"
       " function interface. This option supports the following modes: "
       "`none` - No soft traps, i.e. use hard traps (default)."
       "`call-with-str` - Emit a call to a runtime function that receives the "
       "trap reason as a string."
-      "`call-with-code` - Emit a call to a runtime function that receives an "
-      "integer describing the trap reason. This is better for codesize than "
-      "`call-with-str` but is harder to debug if debug info is missing.">,
-    Values<"none,call-with-str,call-with-code">,
+      "`call-minimal` - Emit a call to a runtime function that takes no "
+      "arguments and uses a custom calling convention if possible. This is "
+      "better for codesize than `call-with-str` but is harder to debug if debug"
+      " info is missing.">,
+    Values<"none,call-with-str,call-minimal">,
     NormalizedValuesScope<"CodeGenOptions::BoundsSafetyTrapModeKind">,
-    NormalizedValues<["Hard", "SoftCallWithTrapString", "SoftCallWithTrapCode"]>,
+    NormalizedValues<["Hard", "SoftCallWithTrapString", "SoftCallMinimal"]>,
     MarshallingInfoEnum<CodeGenOpts<"BoundsSafetyTrapMode">, "Hard">;
 
 def fbounds_safety_soft_trap_function_EQ : Joined<["-"],

clang/lib/CodeGen/CGExpr.cpp

@@ -66,6 +66,14 @@ llvm::cl::opt<bool> ClSanitizeGuardChecks(
     "ubsan-guard-checks", llvm::cl::Optional,
     llvm::cl::desc("Guard UBSAN checks with `llvm.allow.ubsan.check()`."));
 
+// TO_UPSTREAM(BoundsSafety) ON
+llvm::cl::opt<bool> ClBoundsSafetySoftTrapPreserveAllCC(
+    "bounds-safety-soft-trap-preserve-all-cc", llvm::cl::init(true),
+    llvm::cl::Optional,
+    llvm::cl::desc("Use preserve_all calling convention for -fbounds-safety "
+                   "soft trap function calls on x86_64 and arm64"));
+// TO_UPSTREAM(BoundsSafety) OFF
+
 } // namespace clang
 
 //===--------------------------------------------------------------------===//
@@ -4714,35 +4722,59 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked,
       // `__CLANG_BOUNDS_SAFETY_SOFT_TRAP_API_VERSION` and adjust the interface
       // in `bounds_safety_soft_traps.h` if the API is changed.
       llvm::FunctionType *FnType = nullptr;
-      llvm::Constant *SoftTrapCallArg = nullptr;
+      llvm::SmallVector<llvm::Value *, 1> RuntimeCallArgs;
       // Emit calls to one of the interfaces defined in
       // `bounds_safety_soft_traps.h`
       switch (CGM.getCodeGenOpts().getBoundsSafetyTrapMode()) {
-      case CodeGenOptions::BoundsSafetyTrapModeKind::SoftCallWithTrapCode: {
-        // void __bounds_safety_soft_trap_c(uint16_t);
-        // TODO: Set correct value from the `TrapReason` object
-        // (rdar://162824128).
-        SoftTrapCallArg = llvm::ConstantInt::get(CGM.Int16Ty, 0);
+      case CodeGenOptions::BoundsSafetyTrapModeKind::SoftCallMinimal: {
+        // void __bounds_safety_soft_trap();
+        FnType = llvm::FunctionType::get(CGM.VoidTy, {}, false);
+        assert(RuntimeCallArgs.empty());
         break;
       }
       case CodeGenOptions::BoundsSafetyTrapModeKind::SoftCallWithTrapString: {
         // void __bounds_safety_soft_trap_s(const char*);
-        if (!TrapMessage.empty()) {
-          SoftTrapCallArg =
-              CGM.GetOrCreateGlobalStr(TrapMessage, Builder, "trap.reason");
-        } else {
-          SoftTrapCallArg = llvm::Constant::getNullValue(CGM.Int8PtrTy);
-        }
+        FnType = llvm::FunctionType::get(CGM.VoidTy, {CGM.Int8PtrTy}, false);
+        if (!TrapMessage.empty())
+          RuntimeCallArgs.push_back(
+              CGM.GetOrCreateGlobalStr(TrapMessage, Builder, "trap.reason"));
+        else
+          RuntimeCallArgs.push_back(
+              llvm::Constant::getNullValue(CGM.Int8PtrTy));
         break;
       }
       default:
         llvm_unreachable("Unhandled BoundsSafetyTrapMode");
       }
-      FnType = llvm::FunctionType::get(CGM.VoidTy, {SoftTrapCallArg->getType()},
-                                       false);
       auto TrapFunc = CGM.CreateRuntimeFunction(
           FnType, CGM.getCodeGenOpts().BoundsSafetySoftTrapFuncName);
-      TrapCall = EmitNounwindRuntimeCall(TrapFunc, {SoftTrapCallArg});
+
+      // Change calling convention if necessary. This needs to be kept in sync
+      // with `bounds_safety_soft_traps.h`.
+      std::optional<llvm::CallingConv::ID> SoftTrapCC;
+      if (ClBoundsSafetySoftTrapPreserveAllCC &&
+          (CGM.getTarget().getTriple().isAArch64() ||
+           CGM.getTarget().getTriple().getArch() == llvm::Triple::x86_64)) {
+        auto *Fn = cast<llvm::Function>(TrapFunc.getCallee());
+        // This calling convention is used to reduce the codesize at the
+        // callsite. It makes more registers be callee saved which means if
+        // those registers are being used in the caller they no longer need to
+        // be spilled. Unfortunately despite the name this calling convention
+        // doesn't preserve all registers. We should add a new calling
+        // convention that actually preserves almost all the general purposes
+        // registers (rdar://164341162).
+        SoftTrapCC = llvm::CallingConv::PreserveAll;
+        Fn->setCallingConv(SoftTrapCC.value());
+      }
+
+      TrapCall = EmitNounwindRuntimeCall(TrapFunc, RuntimeCallArgs);
+      if (SoftTrapCC.has_value()) {
+        // Marking the called function as having a particular calling convention
+        // (above) does not trigger different codegen at callsites. The call
+        // itself needs to be marked as using the same calling convention too to
+        // get different codegen at callsites.
+        TrapCall->setCallingConv(SoftTrapCC.value());
+      }
       Builder.CreateBr(Cont);
     } else if (CGM.getCodeGenOpts().TrapFuncReturns) {
       auto *TrapID = llvm::ConstantInt::get(CGM.Int8Ty, CheckHandlerID);

clang/lib/Frontend/CompilerInvocation.cpp

@@ -2566,8 +2566,8 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args,
     case CodeGenOptions::BoundsSafetyTrapModeKind::SoftCallWithTrapString:
       Opts.BoundsSafetySoftTrapFuncName = "__bounds_safety_soft_trap_s";
       break;
-    case CodeGenOptions::BoundsSafetyTrapModeKind::SoftCallWithTrapCode:
-      Opts.BoundsSafetySoftTrapFuncName = "__bounds_safety_soft_trap_c";
+    case CodeGenOptions::BoundsSafetyTrapModeKind::SoftCallMinimal:
+      Opts.BoundsSafetySoftTrapFuncName = "__bounds_safety_soft_trap";
       break;
     case CodeGenOptions::BoundsSafetyTrapModeKind::Hard:
       break;

clang/lib/Headers/bounds_safety_soft_traps.h

@@ -22,24 +22,31 @@ extern "C" {
 /// compile time to know which interface version the compiler uses.
 #define __CLANG_BOUNDS_SAFETY_SOFT_TRAP_API_VERSION 0
 
+// `__CLANG_BOUNDS_SAFETY_SOFT_TRAP_FN_ATTRS` is guarded because `preserve_all`
+// is only implemented for x86_64 and arm64. For other targets we get a
+// `'preserve_all' calling convention is not supported for this target` warning.
+#if defined(__aarch64__) || defined(__x86_64__)
+// This attribute is used to try to reduce the codesize impact of making calls
+// to the soft trap runtime function(s).
+#define __CLANG_BOUNDS_SAFETY_SOFT_TRAP_FN_ATTRS __attribute__((preserve_all))
+#else
+#define __CLANG_BOUNDS_SAFETY_SOFT_TRAP_FN_ATTRS
+#endif
+
 /// Called when a `-fbounds-safety` bounds check fails when building with
 /// `-fbounds-safety-soft-traps=call-with-str`. This function is allowed to
 /// to return.
 ///
 /// \param reason A string constant describing the reason for trapping or
 ///        NULL.
+__CLANG_BOUNDS_SAFETY_SOFT_TRAP_FN_ATTRS
 void __bounds_safety_soft_trap_s(const char *reason);
 
-// TODO(dliew): Document the `reason_code` values (rdar://162824128)
-
 /// Called when a `-fbounds-safety` bounds check fails when building with
 /// `-fbounds-safety-soft-traps=call-with-code`. This function is allowed to
-/// to return.
-///
-/// \param reason_code. An integer the represents the reason for trapping.
-///        The values are currently not documented but will be in the future.
-///
-void __bounds_safety_soft_trap_c(uint16_t reason_code);
+/// to return. This function takes no arguments.
+__CLANG_BOUNDS_SAFETY_SOFT_TRAP_FN_ATTRS
+void __bounds_safety_soft_trap(void);
 
 #ifdef __cplusplus
 }

clang/test/BoundsSafety/CodeGen/soft-traps/bounds_safety_soft_traps_h_attributes.c

@@ -0,0 +1,39 @@
+// Check that when a runtime implementation uses the `bounds_safety_soft_traps.h`
+// header that the right calling convention is used.
+
+// x86_64 and arm64 use preserve_all
+
+// RUN: %clang_cc1 -O0 -triple arm64-apple-macos \
+// RUN:   -emit-llvm %s -o -  | \
+// RUN:   FileCheck --check-prefixes=PRESERVE_ALL_CC %s
+
+// RUN: %clang_cc1 -O0 -triple x86_64-apple-macos \
+// RUN:   -emit-llvm %s -o - | \
+// RUN:   FileCheck --check-prefixes=PRESERVE_ALL_CC %s
+
+// Other targets use the normal calling convention
+
+// RUN: %clang_cc1 -O0 -triple i686-apple-macos \
+// RUN:   -emit-llvm %s -o - | \
+// RUN:   FileCheck --check-prefixes=NORMAL_CC %s
+#include <bounds_safety_soft_traps.h>
+
+#if __CLANG_BOUNDS_SAFETY_SOFT_TRAP_API_VERSION > 0
+#error ABI changed
+#endif
+
+// Note the explicit calling convention macro isn't used here. Clang should
+// use the attribute from the declaration in the header.
+
+// PRESERVE_ALL_CC: define preserve_allcc void @__bounds_safety_soft_trap_s(ptr {{.+}})
+// NORMAL_CC: define void @__bounds_safety_soft_trap_s(ptr {{.+}})
+void __bounds_safety_soft_trap_s(const char *reason) {
+
+}
+
+// PRESERVE_ALL_CC: define preserve_allcc void @__bounds_safety_soft_trap()
+// NORMAL_CC: define void @__bounds_safety_soft_trap()
+void __bounds_safety_soft_trap(void) {
+    
+}
+

clang/test/BoundsSafety/CodeGen/soft-traps/call_with_code.c renamed to clang/test/BoundsSafety/CodeGen/soft-traps/call_minimal.c

@@ -1,17 +1,17 @@
-// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 6
+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --check-globals all --version 6
 // RUN: %clang_cc1 -O0 -fbounds-safety -triple arm64-apple-iphoneos \
-// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-with-code | \
+// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-minimal | \
 // RUN:   FileCheck --check-prefixes=UNOPT %s
 
 // Check `-ftrap-function` is ignored for `-fbounds-safety` when using
 // `-fbounds-safety-soft-traps=`
 // RUN: %clang_cc1 -O0 -fbounds-safety -triple arm64-apple-iphoneos \
-// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-with-code \
+// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-minimal \
 // RUN:   -ftrap-function=not_used | \
 // RUN:   FileCheck --check-prefixes=UNOPT %s
 
 // RUN: %clang_cc1 -O2 -fbounds-safety -triple arm64-apple-iphoneos \
-// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-with-code | \
+// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-minimal | \
 // RUN:   FileCheck --check-prefixes=OPT %s
 #include <ptrcheck.h>
 
@@ -37,19 +37,19 @@
 // UNOPT-NEXT:    [[TMP2:%.*]] = icmp ule ptr [[TMP1]], [[WIDE_PTR_UB]], !annotation [[META2]]
 // UNOPT-NEXT:    br i1 [[TMP2]], label %[[CONT:.*]], label %[[TRAP:.*]], !prof [[PROF3:![0-9]+]], !annotation [[META2]]
 // UNOPT:       [[TRAP]]:
-// UNOPT-NEXT:    call void @__bounds_safety_soft_trap_c(i16 0) #[[ATTR2:[0-9]+]], !annotation [[META2]]
+// UNOPT-NEXT:    call preserve_allcc void @__bounds_safety_soft_trap() #[[ATTR2:[0-9]+]], !annotation [[META2]]
 // UNOPT-NEXT:    br label %[[CONT]], !annotation [[META2]]
 // UNOPT:       [[CONT]]:
 // UNOPT-NEXT:    [[TMP3:%.*]] = icmp ule ptr [[ARRAYIDX]], [[TMP1]], !annotation [[META2]]
 // UNOPT-NEXT:    br i1 [[TMP3]], label %[[CONT2:.*]], label %[[TRAP1:.*]], !prof [[PROF3]], !annotation [[META2]]
 // UNOPT:       [[TRAP1]]:
-// UNOPT-NEXT:    call void @__bounds_safety_soft_trap_c(i16 0) #[[ATTR2]], !annotation [[META2]]
+// UNOPT-NEXT:    call preserve_allcc void @__bounds_safety_soft_trap() #[[ATTR2]], !annotation [[META2]]
 // UNOPT-NEXT:    br label %[[CONT2]], !annotation [[META2]]
 // UNOPT:       [[CONT2]]:
 // UNOPT-NEXT:    [[TMP4:%.*]] = icmp uge ptr [[ARRAYIDX]], [[WIDE_PTR_LB]], !annotation [[META4:![0-9]+]]
 // UNOPT-NEXT:    br i1 [[TMP4]], label %[[CONT4:.*]], label %[[TRAP3:.*]], !prof [[PROF3]], !annotation [[META4]]
 // UNOPT:       [[TRAP3]]:
-// UNOPT-NEXT:    call void @__bounds_safety_soft_trap_c(i16 0) #[[ATTR2]], !annotation [[META4]]
+// UNOPT-NEXT:    call preserve_allcc void @__bounds_safety_soft_trap() #[[ATTR2]], !annotation [[META4]]
 // UNOPT-NEXT:    br label %[[CONT4]], !annotation [[META4]]
 // UNOPT:       [[CONT4]]:
 // UNOPT-NEXT:    [[TMP5:%.*]] = load i32, ptr [[ARRAYIDX]], align 4
@@ -69,19 +69,19 @@
 // OPT-NEXT:    [[DOTNOT:%.*]] = icmp ugt ptr [[TMP0]], [[AGG_TEMP_SROA_2_0_COPYLOAD]], !annotation [[META7]]
 // OPT-NEXT:    br i1 [[DOTNOT]], label %[[TRAP:.*]], label %[[CONT:.*]], !prof [[PROF8:![0-9]+]], !annotation [[META7]]
 // OPT:       [[TRAP]]:
-// OPT-NEXT:    tail call void @__bounds_safety_soft_trap_c(i16 0) #[[ATTR1:[0-9]+]], !annotation [[META7]]
+// OPT-NEXT:    tail call preserve_allcc void @__bounds_safety_soft_trap() #[[ATTR1:[0-9]+]], !annotation [[META7]]
 // OPT-NEXT:    br label %[[CONT]], !annotation [[META7]]
 // OPT:       [[CONT]]:
 // OPT-NEXT:    [[DOTNOT5:%.*]] = icmp ugt ptr [[ARRAYIDX]], [[TMP0]], !annotation [[META7]]
 // OPT-NEXT:    br i1 [[DOTNOT5]], label %[[TRAP1:.*]], label %[[CONT2:.*]], !prof [[PROF8]], !annotation [[META7]]
 // OPT:       [[TRAP1]]:
-// OPT-NEXT:    tail call void @__bounds_safety_soft_trap_c(i16 0) #[[ATTR1]], !annotation [[META7]]
+// OPT-NEXT:    tail call preserve_allcc void @__bounds_safety_soft_trap() #[[ATTR1]], !annotation [[META7]]
 // OPT-NEXT:    br label %[[CONT2]], !annotation [[META7]]
 // OPT:       [[CONT2]]:
 // OPT-NEXT:    [[DOTNOT6:%.*]] = icmp ult ptr [[ARRAYIDX]], [[AGG_TEMP_SROA_3_0_COPYLOAD]], !annotation [[META9:![0-9]+]]
 // OPT-NEXT:    br i1 [[DOTNOT6]], label %[[TRAP3:.*]], label %[[CONT4:.*]], !prof [[PROF8]], !annotation [[META9]]
 // OPT:       [[TRAP3]]:
-// OPT-NEXT:    tail call void @__bounds_safety_soft_trap_c(i16 0) #[[ATTR1]], !annotation [[META9]]
+// OPT-NEXT:    tail call preserve_allcc void @__bounds_safety_soft_trap() #[[ATTR1]], !annotation [[META9]]
 // OPT-NEXT:    br label %[[CONT4]], !annotation [[META9]]
 // OPT:       [[CONT4]]:
 // OPT-NEXT:    [[TMP1:%.*]] = load i32, ptr [[ARRAYIDX]], align 4, !tbaa [[TBAA10:![0-9]+]]
@@ -91,11 +91,25 @@ int read(int* __bidi_indexable ptr, int idx) {
     return ptr[idx];
 }
 
+//
+//
+//
+//.
+// UNOPT: attributes #[[ATTR0]] = { noinline nounwind optnone "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+// UNOPT: attributes #[[ATTR1:[0-9]+]] = { nocallback nofree nounwind willreturn memory(argmem: readwrite) }
+// UNOPT: attributes #[[ATTR2]] = { nounwind }
+//.
+// OPT: attributes #[[ATTR0]] = { nounwind "no-trapping-math"="true" "stack-protector-buffer-size"="8" }
+// OPT: attributes #[[ATTR1]] = { nounwind }
 //.
+// UNOPT: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
+// UNOPT: [[META1:![0-9]+]] = !{!"{{.*}}clang version {{.*}}"}
 // UNOPT: [[META2]] = !{!"bounds-safety-check-ptr-le-upper-bound"}
 // UNOPT: [[PROF3]] = !{!"branch_weights", i32 1048575, i32 1}
 // UNOPT: [[META4]] = !{!"bounds-safety-check-ptr-ge-lower-bound"}
 //.
+// OPT: [[META0:![0-9]+]] = !{i32 1, !"wchar_size", i32 4}
+// OPT: [[META1:![0-9]+]] = !{!"{{.*}}clang version {{.*}}"}
 // OPT: [[TBAA2]] = !{[[META3:![0-9]+]], [[META3]], i64 0}
 // OPT: [[META3]] = !{!"p1 int", [[META4:![0-9]+]], i64 0}
 // OPT: [[META4]] = !{!"any pointer", [[META5:![0-9]+]], i64 0}

clang/test/BoundsSafety/CodeGen/soft-traps/call_minimal_calling_convention.c

@@ -0,0 +1,38 @@
+// x86_64 and arm64 use preserve_all
+
+// RUN: %clang_cc1 -O0 -fbounds-safety -triple arm64-apple-macos \
+// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-minimal | \
+// RUN:   FileCheck --check-prefixes=PRESERVE_ALL_CC,COMMON %s
+
+// RUN: %clang_cc1 -O0 -fbounds-safety -triple x86_64-apple-macos \
+// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-minimal | \
+// RUN:   FileCheck --check-prefixes=PRESERVE_ALL_CC,COMMON %s
+
+// Other targets use the normal calling convention
+
+// RUN: %clang_cc1 -O0 -fbounds-safety -triple i686-apple-macos \
+// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-minimal | \
+// RUN:   FileCheck --check-prefixes=NORMAL_CC,COMMON %s
+
+// Hidden flag can also switch off custom calling convention
+
+// RUN: %clang_cc1 -O0 -fbounds-safety -triple arm64-apple-macos \
+// RUN:   -emit-llvm %s -o - -fbounds-safety-soft-traps=call-minimal \
+// RUN:   -mllvm -bounds-safety-soft-trap-preserve-all-cc=false | \
+// RUN:   FileCheck --check-prefixes=NORMAL_CC,COMMON %s
+
+#include <ptrcheck.h>
+
+// PRESERVE_ALL_CC: call preserve_allcc void @__bounds_safety_soft_trap()
+// PRESERVE_ALL_CC: call preserve_allcc void @__bounds_safety_soft_trap()
+// PRESERVE_ALL_CC: call preserve_allcc void @__bounds_safety_soft_trap()
+// NORMAL_CC: call void @__bounds_safety_soft_trap()
+// NORMAL_CC: call void @__bounds_safety_soft_trap()
+// NORMAL_CC: call void @__bounds_safety_soft_trap()
+// COMMON-NOT: call {{.*}} void @__bounds_safety_soft_trap()
+int read(int* __bidi_indexable ptr, int idx) {
+    return ptr[idx];
+}
+
+// PRESERVE_ALL_CC: declare preserve_allcc void @__bounds_safety_soft_trap()
+// NORMAL_CC: declare void @__bounds_safety_soft_trap()