[UBSan][BoundsSafety] Implement support for more expressive "trap reasons"

In 29992cf (llvm#145967) support was added
for "trap reasons" on traps emitted in UBSan in trapping mode (e.g.
`-fsanitize-trap=undefined`). This improved the debugging experience by
attaching the reason for trapping as a string on the debug info on trap
instructions. Consumers such as LLDB can display this trap reason string
when the trap is reached.

A limitation of that patch is that the trap reason string is hard-coded
for each `SanitizerKind` even though the compiler actually has much more
information about the trap available at compile time that could be shown
to the user.

This patch is an incremental step in fixing that. It consists of two
main steps.

**1. Introduce infrastructure for building trap reason strings **

To make it convenient to construct trap reason strings this patch
re-uses Clang's powerful diagnostic infrastructure to provide a
convenient API for constructing trap reason strings. This is achieved
by:

* Introducing a new `Trap` diagnostic kind to represent trap
  diagnostics in TableGen files.
* Adding a new `CodeGen` diagnostic component. While this part probably
  isn't technically necessary it seemed like I should follow the
  existing convention used by the diagnostic system.
* Adding `DiagnosticCodeGenKinds.td` to describe the different trap
  reasons.
* Add the `RuntimeTrapDiagnosticBuilder` class to provide an interface
  for constructing trap reason strings and the trap category. Note this
  API while similar to `DiagnosticBuilder` has different semantics which
  are described in the code comments. In particular the behavior when
  the destructor is called is very different.
* Adding `CodeGenModule::RuntimeDiag()` as a convenient constructor for
  the `RuntimeTrapDiagnosticBuilder`.

This use of the diagnostic system is a little unusual in that the
emitted trap diagnostics aren't actually consumed by normal diagnostic
consumers (e.g. the console). Instead the `RuntimeTrapDiagnosticBuilder`
is just used to format a string, so in effect the builder is somewhat
analagous to "printf". However, re-using the diagnostics system in this
way brings a several benefits:

* The powerful diagnostic templating languge (e.g. `%select`) can be
  used.
* Formatting Clang data types (e.g. `Type`, `Expr`, etc.) just
  work out-of-the-box.
* Describing trap reasons in tablegen files opens the door for
  translation to different languages in the future.
* The `RuntimeTrapDiagnosticBuilder` API is very similar to
  `DiagnosticBuilder` which makes it easy to use by anyone already
  familiar with Clang's diagnostic system.

While UBSan is the first consumer of this new infrastructure the intent
is to use this to overhaul how trap reasons are implemented in the
`-fbounds-safety` implementation (currently exists downstream).

**2. Apply the new infrastructure to UBSan checks for arithmetic overflow**

To demonstrate using `RuntimeTrapDiagnosticBuilder` this patch applies
it to UBSan traps for arithmetic overflow. The intention is that we
would iteratively switch to using the `RuntimeTrapDiagnosticBuilder` for
all UBSan traps where it makes sense in future patches.

Previously for code like

```
int test(int a, int b) { return a + b; }
```

The trap reason string looked like

```
Undefined Behavior Sanitizer: Integer addition overflowed
```

now the trap message looks like:

```
Undefined Behavior Sanitizer: signed integer addition overflow in 'a + b'
```

This string is much more specific because

* It explains if signed or unsigned overflow occurred
* It actually shows the expression that overflowed

This seems a lot more helpful.

One possible downside of this approach is it may blow up Debug info size
because now there can be many more distinct trap reason strings. If this
is a concern we may want to add a flag to make it possible to continue
to use the original hard-coded trap messages to avoid increasing the
size of Debug info.

rdar://158612755

Author: delcypher

clang/include/clang/Basic/AllDiagnosticKinds.inc

@@ -30,4 +30,5 @@
 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
 #include "clang/Basic/DiagnosticInstallAPIKinds.inc"
+#include "clang/Basic/DiagnosticTrapKinds.inc"
 // clang-format on

clang/include/clang/Basic/AllDiagnostics.h

@@ -26,6 +26,7 @@
 #include "clang/Basic/DiagnosticRefactoring.h"
 #include "clang/Basic/DiagnosticSema.h"
 #include "clang/Basic/DiagnosticSerialization.h"
+#include "clang/Basic/DiagnosticTrap.h"
 
 namespace clang {
 template <size_t SizeOfStr, typename FieldType> class StringSizerHelper {

clang/include/clang/Basic/CMakeLists.txt

@@ -33,6 +33,7 @@ clang_diag_gen(Parse)
 clang_diag_gen(Refactoring)
 clang_diag_gen(Sema)
 clang_diag_gen(Serialization)
+clang_diag_gen(Trap)
 clang_tablegen(DiagnosticGroups.inc -gen-clang-diag-groups
   SOURCE Diagnostic.td
   TARGET ClangDiagnosticGroups)

clang/include/clang/Basic/Diagnostic.h

@@ -1233,6 +1233,7 @@ class DiagnosticBuilder : public StreamingDiagnostic {
   friend class DiagnosticsEngine;
   friend class PartialDiagnostic;
   friend class Diagnostic;
+  friend class RuntimeTrapDiagnosticBuilder;
 
   mutable DiagnosticsEngine *DiagObj = nullptr;
 
@@ -1534,6 +1535,72 @@ inline DiagnosticBuilder DiagnosticsEngine::Report(unsigned DiagID) {
   return Report(SourceLocation(), DiagID);
 }
 
+//===----------------------------------------------------------------------===//
+// RuntimeTrapDiagnosticBuilder
+//===----------------------------------------------------------------------===//
+/// Class to make it convenient to construct "trap reasons" to attach to trap
+/// instructions.
+///
+/// Although this class inherits from `DiagnosticBuilder` it has very different
+/// semantics.
+///
+/// * This class should only be used with trap diagnostics (declared in
+/// `DiagnosticTrapKinds.td`).
+/// * The `RuntimeTrapDiagnosticBuilder` does not emit diagnostics to the normal
+///   diagnostics consumers on destruction like normal Diagnostic builders.
+///   Instead it does nothing on destruction.
+/// * Users of this class that want to retrieve the "trap reason" should call
+///   call the `getMessage()` and `getCategory()` and use those results before
+///   the builder is destroyed.
+/// * Unlike the `DiagnosticBuilder` the `RuntimeDiagnosticBuilder` should never
+/// be created as a temporary (i.e. rvalue) and instead should be stored. This
+/// is because the class is only useful if `getMessage()` and `getCategory()`
+/// can be called.
+///
+/// Given that this class inherits from `DiagnosticBuilder` it inherits all of
+/// its abilities to format diagnostic messages and consume various types in
+/// class (e.g. Type, Exprs, etc.). This makes it particularly suited to
+/// printing types and expressions from the AST while codegen-ing runtime
+/// checks.
+///
+///
+/// Example use via the `CodeGenModule::RuntimeDiag` helper.
+///
+/// \code
+/// {
+///   auto* RTDB = CGM.RuntimeDiag(diag::trap_diagnostic);
+///   *RTDB << 0 << SomeExpr << SomeType;
+///   consume(RTDB->getCategory(), RTDB->getMessage());
+/// }
+/// \endcode
+///
+///
+class RuntimeTrapDiagnosticBuilder : public DiagnosticBuilder {
+public:
+  RuntimeTrapDiagnosticBuilder(DiagnosticsEngine *DiagObj, unsigned DiagID);
+  ~RuntimeTrapDiagnosticBuilder();
+
+  // Prevent accidentally copying or assigning
+  RuntimeTrapDiagnosticBuilder &
+  operator=(const RuntimeTrapDiagnosticBuilder &) = delete;
+  RuntimeTrapDiagnosticBuilder &
+  operator=(const RuntimeTrapDiagnosticBuilder &&) = delete;
+  RuntimeTrapDiagnosticBuilder(const RuntimeTrapDiagnosticBuilder &) = delete;
+  RuntimeTrapDiagnosticBuilder(const RuntimeTrapDiagnosticBuilder &&) = delete;
+
+  /// \return Format the trap message and return it. Note the lifetime of
+  /// the underlying storage pointed to by the returned StringRef is the same
+  /// as the lifetime of this class. This means it is likely unsafe to store
+  /// the returned StringRef.
+  StringRef getMessage();
+  /// \return Return the trap category. These are the `CategoryName` property
+  /// of `trap` diagnostics declared in `DiagnosticTrapKinds.td`.
+  StringRef getCategory();
+
+private:
+  llvm::SmallVector<char, 64> MessageStorage;
+};
+
 //===----------------------------------------------------------------------===//
 // Diagnostic
 //===----------------------------------------------------------------------===//

clang/include/clang/Basic/Diagnostic.td

@@ -30,6 +30,7 @@ def CLASS_REMARK    : DiagClass;
 def CLASS_WARNING   : DiagClass;
 def CLASS_EXTENSION : DiagClass;
 def CLASS_ERROR     : DiagClass;
+def CLASS_TRAP      : DiagClass;
 
 // Responses to a diagnostic in a SFINAE context.
 class SFINAEResponse;
@@ -144,7 +145,8 @@ class Extension<string str> : Diagnostic<str, CLASS_EXTENSION, SEV_Ignored>;
 class ExtWarn<string str>   : Diagnostic<str, CLASS_EXTENSION, SEV_Warning>;
 // Notes can provide supplementary information on errors, warnings, and remarks.
 class Note<string str>      : Diagnostic<str, CLASS_NOTE, SEV_Fatal/*ignored*/>;
-
+// Traps messages attached to traps in debug info
+class Trap<string str>      : Diagnostic<str, CLASS_TRAP, SEV_Fatal/*ignored*/>;
 
 class DefaultIgnore { Severity DefaultSeverity = SEV_Ignored; }
 class DefaultWarn   { Severity DefaultSeverity = SEV_Warning; }
@@ -235,3 +237,4 @@ include "DiagnosticParseKinds.td"
 include "DiagnosticRefactoringKinds.td"
 include "DiagnosticSemaKinds.td"
 include "DiagnosticSerializationKinds.td"
+include "DiagnosticTrapKinds.td"

clang/include/clang/Basic/DiagnosticIDs.h

@@ -47,6 +47,7 @@ enum {
   DIAG_SIZE_ANALYSIS = 100,
   DIAG_SIZE_REFACTORING = 1000,
   DIAG_SIZE_INSTALLAPI = 100,
+  DIAG_SIZE_TRAP          =  100,
 };
 // Start position for diagnostics.
 // clang-format off
@@ -64,7 +65,8 @@ enum {
   DIAG_START_ANALYSIS      = DIAG_START_SEMA          + static_cast<int>(DIAG_SIZE_SEMA),
   DIAG_START_REFACTORING   = DIAG_START_ANALYSIS      + static_cast<int>(DIAG_SIZE_ANALYSIS),
   DIAG_START_INSTALLAPI    = DIAG_START_REFACTORING   + static_cast<int>(DIAG_SIZE_REFACTORING),
-  DIAG_UPPER_LIMIT         = DIAG_START_INSTALLAPI    + static_cast<int>(DIAG_SIZE_INSTALLAPI)
+  DIAG_START_TRAP          = DIAG_START_INSTALLAPI    + static_cast<int>(DIAG_SIZE_INSTALLAPI),
+  DIAG_UPPER_LIMIT         = DIAG_START_TRAP          + static_cast<int>(DIAG_SIZE_TRAP)
 };
 // clang-format on
 
@@ -189,7 +191,8 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
     CLASS_REMARK = 0x02,
     CLASS_WARNING = 0x03,
     CLASS_EXTENSION = 0x04,
-    CLASS_ERROR = 0x05
+    CLASS_ERROR = 0x05,
+    CLASS_TRAP = 0x06
   };
 
   static bool IsCustomDiag(diag::kind Diag) {
@@ -363,6 +366,10 @@ class DiagnosticIDs : public RefCountedBase<DiagnosticIDs> {
   ///
   bool isExtensionDiag(unsigned DiagID, bool &EnabledByDefault) const;
 
+  bool isTrapDiag(unsigned DiagID) const {
+    return getDiagClass(DiagID) == CLASS_TRAP;
+  }
+
   /// Given a group ID, returns the flag that toggles the group.
   /// For example, for Group::DeprecatedDeclarations, returns
   /// "deprecated-declarations".

clang/include/clang/Basic/DiagnosticTrap.h

@@ -0,0 +1,15 @@
+//===--- DiagnosticTrap.h - Diagnostics for trap instructions ---*- 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_CLANG_BASIC_TRAP_H
+#define LLVM_CLANG_BASIC_TRAP_H
+
+#include "clang/Basic/Diagnostic.h"
+#include "clang/Basic/DiagnosticTrapInterface.inc"
+
+#endif

clang/include/clang/Basic/DiagnosticTrapKinds.td

@@ -0,0 +1,26 @@
+//==--- DiagnosticTrapKinds.td - CodeGen Diagnostics -------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+
+//===----------------------------------------------------------------------===//
+// Trap Diagnostics
+//
+// These are diagnostics that are emitted into Debug Info, rather than to the
+// traditional consumers like the terminal. Their primary purpose is to make
+// debugging traps (e.g. `-fsanitize-trap=undefined`) easier by attaching
+// a trap category and reason to the trap instruction that tools like a debugger
+// can show.
+//===----------------------------------------------------------------------===//
+let Component = "Trap" in {
+let CategoryName = "Undefined Behavior Sanitizer" in {
+
+def trap_ubsan_arith_overflow : Trap<
+  "%select{unsigned|signed}0 integer "
+  "%select{addition|subtraction|multiplication}1 overflow in %2">;
+
+}
+}

clang/lib/Basic/Diagnostic.cpp

@@ -664,6 +664,8 @@ void DiagnosticsEngine::Report(const StoredDiagnostic &storedDiag) {
 
 void DiagnosticsEngine::Report(Level DiagLevel, const Diagnostic &Info) {
   assert(DiagLevel != Ignored && "Cannot emit ignored diagnostics!");
+  assert(!getDiagnosticIDs()->isTrapDiag(Info.getID()) &&
+         "Trap diagnostics should not be consumed by the DiagnosticsEngine");
   Client->HandleDiagnostic(DiagLevel, Info);
   if (Client->IncludeInDiagnosticCounts()) {
     if (DiagLevel == Warning)
@@ -793,6 +795,35 @@ DiagnosticBuilder::DiagnosticBuilder(const DiagnosticBuilder &D)
   D.Clear();
 }
 
+RuntimeTrapDiagnosticBuilder::RuntimeTrapDiagnosticBuilder(
+    DiagnosticsEngine *DiagObj, unsigned DiagID)
+    : DiagnosticBuilder(DiagObj, SourceLocation(), DiagID) {
+  assert(DiagObj->getDiagnosticIDs()->isTrapDiag(DiagID));
+}
+
+RuntimeTrapDiagnosticBuilder::~RuntimeTrapDiagnosticBuilder() {
+  // Make sure that when `DiagnosticBuilder::~DiagnosticBuilder()`
+  // calls `Emit()` that it does nothing.
+  Clear();
+}
+
+StringRef RuntimeTrapDiagnosticBuilder::getMessage() {
+  if (MessageStorage.size() == 0) {
+    // Render the Diagnostic
+    Diagnostic Info(DiagObj, *this);
+    Info.FormatDiagnostic(MessageStorage);
+  }
+  return StringRef(MessageStorage.data(), MessageStorage.size());
+}
+
+StringRef RuntimeTrapDiagnosticBuilder::getCategory() {
+  auto CategoryID =
+      DiagObj->getDiagnosticIDs()->getCategoryNumberForDiag(DiagID);
+  if (CategoryID == 0)
+    return "";
+  return DiagObj->getDiagnosticIDs()->getCategoryNameFromID(CategoryID);
+}
+
 Diagnostic::Diagnostic(const DiagnosticsEngine *DO,
                        const DiagnosticBuilder &DiagBuilder)
     : DiagObj(DO), DiagLoc(DiagBuilder.DiagLoc), DiagID(DiagBuilder.DiagID),

clang/lib/Basic/DiagnosticIDs.cpp

@@ -69,6 +69,7 @@ enum DiagnosticClass {
   CLASS_WARNING = DiagnosticIDs::CLASS_WARNING,
   CLASS_EXTENSION = DiagnosticIDs::CLASS_EXTENSION,
   CLASS_ERROR = DiagnosticIDs::CLASS_ERROR,
+  CLASS_TRAP = DiagnosticIDs::CLASS_TRAP,
 };
 
 struct StaticDiagInfoRec {
@@ -139,6 +140,7 @@ VALIDATE_DIAG_SIZE(SEMA)
 VALIDATE_DIAG_SIZE(ANALYSIS)
 VALIDATE_DIAG_SIZE(REFACTORING)
 VALIDATE_DIAG_SIZE(INSTALLAPI)
+VALIDATE_DIAG_SIZE(TRAP)
 #undef VALIDATE_DIAG_SIZE
 #undef STRINGIFY_NAME
 
@@ -171,6 +173,7 @@ const StaticDiagInfoRec StaticDiagInfo[] = {
 #include "clang/Basic/DiagnosticAnalysisKinds.inc"
 #include "clang/Basic/DiagnosticRefactoringKinds.inc"
 #include "clang/Basic/DiagnosticInstallAPIKinds.inc"
+#include "clang/Basic/DiagnosticTrapKinds.inc"
 // clang-format on
 #undef DIAG
 };
@@ -214,6 +217,7 @@ CATEGORY(SEMA, CROSSTU)
 CATEGORY(ANALYSIS, SEMA)
 CATEGORY(REFACTORING, ANALYSIS)
 CATEGORY(INSTALLAPI, REFACTORING)
+CATEGORY(TRAP, INSTALLAPI)
 #undef CATEGORY
 
   // Avoid out of bounds reads.