[NFC][BoundsSafety] Adopt TrapReason in CodeGenFunction::EmitBoundsSafetyTrapCheck

This is the first step in adopting the new trap reasons infrastructure.
This patch introduces the `trap_bs_fallback` diagnostic and this just
uses the existing infrastructure for computing trap reason reasons. Thus
there is no user visible change in behavior with this patch.

Future patches will start introducing new diagnostics so more specific
trap reason messages can be created.

rdar://158623471

Author: delcypher

clang/include/clang/Basic/DiagnosticBoundsSafetyTrapKinds.td

@@ -0,0 +1,19 @@
+//==--- DiagnosticBoundsSafetyTrapKinds.td --------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+// These are the trap diagnostics used by -fbounds-safety
+//===----------------------------------------------------------------------===//
+
+let Component = "Trap" in {
+let CategoryName = "Bounds check failed" in {
+
+// Used for falling back to the legacy infrastructure for constructing
+// trap reason strings.
+def trap_bs_fallback : Trap<"%0">;
+
+}
+}

clang/include/clang/Basic/DiagnosticTrapKinds.td

@@ -28,3 +28,7 @@ def trap_ubsan_arith_overflow : Trap<
 
 }
 }
+
+// TO_UPSTREAM(BoundsSafety) ON
+include "DiagnosticBoundsSafetyTrapKinds.td"
+// TO_UPSTREAM(BoundsSafety) OFF

clang/lib/CodeGen/CGExpr.cpp

@@ -36,6 +36,7 @@
 #include "clang/AST/StmtVisitor.h"
 #include "clang/Basic/Builtins.h"
 #include "clang/Basic/CodeGenOptions.h"
+#include "clang/Basic/DiagnosticTrap.h" // TO_UPSTREAM(BoundsSafety)
 #include "clang/Basic/Module.h"
 #include "clang/Basic/SourceManager.h"
 #include "llvm/ADT/STLExtras.h"
@@ -4855,8 +4856,7 @@ void CodeGenFunction::EmitUnreachable(SourceLocation Loc) {
 void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked,
                                     SanitizerHandler CheckHandlerID,
                                     bool NoMerge, const TrapReason *TR,
-                                    StringRef Annotation,
-                                    StringRef BoundsSafetyTrapMessage) {
+                                    StringRef Annotation) {
   llvm::BasicBlock *Cont = createBasicBlock("cont");
 
   // If we're optimizing, collapse all calls to trap down to just one per
@@ -4870,26 +4870,24 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked,
   llvm::StringRef TrapMessage;
   llvm::StringRef TrapCategory;
   auto DebugTrapReasonKind = CGM.getCodeGenOpts().getSanitizeDebugTrapReasons();
+
+  /* TO_UPSTREAM(BoundsSafety) ON*/
   if (TR && !TR->isEmpty() &&
-      DebugTrapReasonKind ==
-          CodeGenOptions::SanitizeDebugTrapReasonKind::Detailed) {
+      (DebugTrapReasonKind ==
+           CodeGenOptions::SanitizeDebugTrapReasonKind::Detailed ||
+       CheckHandlerID == SanitizerHandler::BoundsSafety)) {
     TrapMessage = TR->getMessage();
     TrapCategory = TR->getCategory();
   } else {
-    /* TO_UPSTREAM(BoundsSafety) ON*/
-    // FIXME: Move to using `TrapReason` (rdar://158623471).
-    if (CheckHandlerID == SanitizerHandler::BoundsSafety) {
-      TrapMessage = BoundsSafetyTrapMessage;
-      TrapCategory = GetBoundsSafetyTrapMessagePrefix();
-    } else {
-      TrapMessage = GetUBSanTrapForHandler(CheckHandlerID);
-      TrapCategory = "Undefined Behavior Sanitizer";
-    }
+    assert(CheckHandlerID != SanitizerHandler::BoundsSafety);
+    TrapMessage = GetUBSanTrapForHandler(CheckHandlerID);
+    TrapCategory = "Undefined Behavior Sanitizer";
   }
 
   if (getDebugInfo() && !(TrapMessage.empty() && TrapCategory.empty()) &&
-      DebugTrapReasonKind !=
-          CodeGenOptions::SanitizeDebugTrapReasonKind::None &&
+      (DebugTrapReasonKind !=
+           CodeGenOptions::SanitizeDebugTrapReasonKind::None ||
+       CheckHandlerID == SanitizerHandler::BoundsSafety) &&
       TrapLocation) {
     TrapLocation = getDebugInfo()->CreateTrapFailureMessageFor(
         TrapLocation, TrapCategory, TrapMessage);
@@ -4979,19 +4977,26 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked,
   EmitBlock(Cont);
 }
 
-void CodeGenFunction::EmitBoundsSafetyTrapCheck(llvm::Value *Checked,
-                                             BoundsSafetyTrapKind kind,
-                                             BoundsSafetyTrapCtx::Kind TrapCtx) {
+void CodeGenFunction::EmitBoundsSafetyTrapCheck(
+    llvm::Value *Checked, BoundsSafetyTrapKind kind,
+    BoundsSafetyTrapCtx::Kind TrapCtx, TrapReason *TR) {
   auto OptRemark = GetBoundsSafetyOptRemarkForTrap(kind);
   assert(BoundsSafetyOptRemarkScope::InScope(this, OptRemark));
 
+  // Fallback: If a TrapReason object isn't provided use the legacy approach
+  // for constructing
+  TrapReason TempTR;
+  if (!TR) {
+    CGM.BuildTrapReason(diag::trap_bs_fallback, TempTR)
+        << GetBoundsSafetyTrapMessageSuffix(kind, TrapCtx);
+  }
+
   // We still need to pass `OptRemark` because not all emitted instructions
   // can be covered by BoundsSafetyOptRemarkScope. This is because EmitTrapCheck
   // caches basic blocks that contain instructions that need annotating.
   EmitTrapCheck(Checked, SanitizerHandler::BoundsSafety,
                 /*NoMerge=*/CGM.getCodeGenOpts().BoundsSafetyUniqueTraps,
-                /*TR=*/nullptr, GetBoundsSafetyOptRemarkString(OptRemark),
-                GetBoundsSafetyTrapMessageSuffix(kind, TrapCtx));
+                TR ? TR : &TempTR, GetBoundsSafetyOptRemarkString(OptRemark));
 }
 
 llvm::CallInst *CodeGenFunction::EmitTrapCall(llvm::Intrinsic::ID IntrID) {

clang/lib/CodeGen/CodeGenFunction.h

@@ -5425,7 +5425,7 @@ class CodeGenFunction : public CodeGenTypeCache {
   /// conditional branch to it, for the -ftrapv checks.
   void EmitTrapCheck(llvm::Value *Checked, SanitizerHandler CheckHandlerID,
                      bool NoMerge = false, const TrapReason *TR = nullptr,
-                     StringRef Annotation = "", StringRef TrapMessage = "");
+                     StringRef Annotation = "");
 
   /* TO_UPSTREAM(BoundsSafety) ON*/
   /// Create a basic block that will call the trap intrinsic for -fbounds-safety, and
@@ -5435,7 +5435,8 @@ class CodeGenFunction : public CodeGenTypeCache {
   /// must be in scope when this method is called.
   void EmitBoundsSafetyTrapCheck(
       llvm::Value *Checked, BoundsSafetyTrapKind kind,
-      BoundsSafetyTrapCtx::Kind TrapCtx = BoundsSafetyTrapCtx::UNKNOWN);
+      BoundsSafetyTrapCtx::Kind TrapCtx = BoundsSafetyTrapCtx::UNKNOWN,
+      TrapReason *TR = nullptr);
   /* TO_UPSTREAM(BoundsSafety) OFF*/
 
   /// Emit a call to trap or debugtrap and attach function attribute