UBSan ␇ runtime

[jfb]

Summary

Yes, this is April 1st and the patch isn't particularly serious.

There is a ␇ UBSan runtime available. It is named in honor of Bell Labs (who
gave us the C programming language and Undefined Behavior), the ASCII "bell"
character (value 07), and famed violinist Joshua Bell. It is not related to
the city of Bell in California. This runtime will emit sound, most traditionally
the terminal's bell sound, when undefined behavior occurs.

To use the minimal runtime, add -fsanitize-bel-runtime to the clang command
line options. For example, if you're used to compiling with
-fsanitize=undefined, you could enable the minimal runtime with
-fsanitize=undefined -fsanitize-bel-runtime.

When combined with -fsanitize-recover=undefined, the ␇ runtime will simply
chime on Undefined Behavior without killing the program for each chime. To avoid
Pavlovian effects, the ␇ runtime uses Advanced Compiler Techniques called
"heuristics" to avoid chiming too often at the same location.

On macOS, the ␇ runtime will helpfully announce what specific undefined behavior
you've encountered, and then taunt you.

[regehr]

Sorry but I don't think this can land until it has options for sending sanitizer output to Slack channels and SMS numbers.

[lebedev.ri]

compiler-rt/lib/ubsan_bel/ubsan_bel_handlers.cpp

40–42

I'm not sure we should be introducing randomness into UB handler.
I think what this instead should do, is attach gdb to the process and fix the UB-invoking instructions.

[jfb]

compiler-rt/lib/ubsan_bel/ubsan_bel_handlers.cpp

40–42

Hmm, should it be sudo-random to ensure that rm -rf / works?

What is gdb? Is it like lldb but not as low-level?

[jfb]

I don't think the world is ready for this.

clang/docs/UndefinedBehaviorSanitizer.rst

 basic issue logging and deduplication, and does not support
 ``-fsanitize=function`` and ``-fsanitize=vptr`` checking.
 
 To use the minimal runtime, add ``-fsanitize-minimal-runtime`` to the clang
 command line options. For example, if you're used to compiling with
 ``-fsanitize=undefined``, you could enable the minimal runtime with
 ``-fsanitize=undefined -fsanitize-minimal-runtime``.
 
+␇ Runtime
+=========
+
+There is a ␇ UBSan runtime available. It is named in honor of Bell Labs (who
+gave us the C programming language and Undefined Behavior), the ASCII "bell"
+character (value `07`), and famed violinist Joshua Bell. It is not related to
+the city of Bell in California. This runtime will emit sound, most traditionally
+the terminal's bell sound, when undefined behavior occurs.
+
+To use the minimal runtime, add ``-fsanitize-bel-runtime`` to the clang command
+line options. For example, if you're used to compiling with
+``-fsanitize=undefined``, you could enable the minimal runtime with
+``-fsanitize=undefined -fsanitize-bel-runtime``.
+
+When combined with ``-fsanitize-recover=undefined``, the ␇ runtime will simply
+chime on Undefined Behavior without killing the program for each chime. To avoid
+Pavlovian effects, the ␇ runtime uses Advanced Compiler Techniques called
+"heuristics" to avoid chiming too often at the same location.
+
+On macOS, the ␇ runtime will helpfully announce what specific undefined behavior
+you've encountered, and then taunt you.
+
 Stack traces and report symbolization
 =====================================
 If you want UBSan to print symbolized stack trace for each error report, you
 will need to:
 
 #. Compile with ``-g`` and ``-fno-omit-frame-pointer`` to get proper debug
    information in your binary.
 #. Run your program with environment variable

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(SanitizeAddressUseOdrIndicator, 1, 0) ///< Enable ODR indicator globals
 CODEGENOPT(SanitizeMemoryTrackOrigins, 2, 0) ///< Enable tracking origins in
                                              ///< MemorySanitizer
 CODEGENOPT(SanitizeMemoryUseAfterDtor, 1, 0) ///< Enable use-after-delete detection
                                              ///< in MemorySanitizer
 CODEGENOPT(SanitizeCfiCrossDso, 1, 0) ///< Enable cross-dso support in CFI.
 CODEGENOPT(SanitizeMinimalRuntime, 1, 0) ///< Use "_minimal" sanitizer runtime for
                                          ///< diagnostics.
+CODEGENOPT(SanitizeBelRuntime, 1, 0) ///< Use "_bel" sanitizer runtime for diagnostics.
 CODEGENOPT(SanitizeCfiICallGeneralizePointers, 1, 0) ///< Generalize pointer types in
                                                      ///< CFI icall function signatures
 CODEGENOPT(SanitizeCfiCanonicalJumpTables, 1, 0) ///< Make jump table symbols canonical
                                                  ///< instead of creating a local jump table.
 CODEGENOPT(SanitizeCoverageType, 2, 0) ///< Type of sanitizer coverage
                                        ///< instrumentation.
 CODEGENOPT(SanitizeCoverageIndirectCalls, 1, 0) ///< Enable sanitizer coverage
                                                 ///< for indirect calls.

clang/include/clang/Driver/Options.td

 def fsanitize_undefined_trap_on_error : Flag<["-"], "fsanitize-undefined-trap-on-error">,
                                         Group<f_clang_Group>;
 def fno_sanitize_undefined_trap_on_error : Flag<["-"], "fno-sanitize-undefined-trap-on-error">,
                                            Group<f_clang_Group>;
 def fsanitize_minimal_runtime : Flag<["-"], "fsanitize-minimal-runtime">,
                                         Group<f_clang_Group>;
 def fno_sanitize_minimal_runtime : Flag<["-"], "fno-sanitize-minimal-runtime">,
                                         Group<f_clang_Group>;
+def fsanitize_bel_runtime : Flag<["-"], "fsanitize-bel-runtime">, Group<f_clang_Group>;
+def fno_sanitize_bel_runtime : Flag<["-"], "fno-sanitize-bel-runtime">, Group<f_clang_Group>;
 def fsanitize_link_runtime : Flag<["-"], "fsanitize-link-runtime">,
                            Group<f_clang_Group>;
 def fno_sanitize_link_runtime : Flag<["-"], "fno-sanitize-link-runtime">,
                               Group<f_clang_Group>;
 def fsanitize_link_cxx_runtime : Flag<["-"], "fsanitize-link-c++-runtime">,
                                  Group<f_clang_Group>;
 def fno_sanitize_link_cxx_runtime : Flag<["-"], "fno-sanitize-link-c++-runtime">,
                                     Group<f_clang_Group>;

clang/include/clang/Driver/SanitizerArgs.h

class SanitizerArgs {
   bool LinkCXXRuntimes = false;
   bool NeedPIE = false;
   bool SafeStackRuntime = false;
   bool Stats = false;
   bool TsanMemoryAccess = true;
   bool TsanFuncEntryExit = true;
   bool TsanAtomics = true;
   bool MinimalRuntime = false;
+  bool BelRuntime = false;
   // True if cross-dso CFI support if provided by the system (i.e. Android).
   bool ImplicitCfiRuntime = false;
 
  public:
   /// Parses the sanitizer arguments from an argument list.
   SanitizerArgs(const ToolChain &TC, const llvm::opt::ArgList &Args);
 
   bool needsSharedRt() const { return SharedRuntime; }
 
   bool needsAsanRt() const { return Sanitizers.has(SanitizerKind::Address); }
   bool needsHwasanRt() const {
     return Sanitizers.has(SanitizerKind::HWAddress);
   }
   bool needsTsanRt() const { return Sanitizers.has(SanitizerKind::Thread); }
   bool needsMsanRt() const { return Sanitizers.has(SanitizerKind::Memory); }
   bool needsFuzzer() const { return Sanitizers.has(SanitizerKind::Fuzzer); }
   bool needsLsanRt() const {
     return Sanitizers.has(SanitizerKind::Leak) &&
            !Sanitizers.has(SanitizerKind::Address) &&
            !Sanitizers.has(SanitizerKind::HWAddress);
   }
   bool needsUbsanRt() const;
   bool requiresMinimalRuntime() const { return MinimalRuntime; }
+  bool requiresBelRuntime() const { return BelRuntime; }
   bool needsDfsanRt() const { return Sanitizers.has(SanitizerKind::DataFlow); }
   bool needsSafeStackRt() const { return SafeStackRuntime; }
   bool needsCfiRt() const;
   bool needsCfiDiagRt() const;
   bool needsStatsRt() const { return Stats; }
   bool needsScudoRt() const { return Sanitizers.has(SanitizerKind::Scudo); }
 
   bool requiresPIE() const;

clang/lib/CodeGen/CGExpr.cpp

static void emitCheckHandlerCall(CodeGenFunction &CGF,
   Optional<ApplyDebugLocation> DL;
   if (!CGF.Builder.getCurrentDebugLocation()) {
     // Ensure that the call has at least an artificial debug location.
     DL.emplace(CGF, SourceLocation());
   }
   bool NeedsAbortSuffix =
       IsFatal && RecoverKind != CheckRecoverableKind::Unrecoverable;
   bool MinimalRuntime = CGF.CGM.getCodeGenOpts().SanitizeMinimalRuntime;
+  bool BelRuntime = CGF.CGM.getCodeGenOpts().SanitizeBelRuntime;
   const SanitizerHandlerInfo &CheckInfo = SanitizerHandlers[CheckHandler];
   const StringRef CheckName = CheckInfo.Name;
   std::string FnName = "__ubsan_handle_" + CheckName.str();
-  if (CheckInfo.Version && !MinimalRuntime)
+  if (CheckInfo.Version && !MinimalRuntime && !BelRuntime)
     FnName += "_v" + llvm::utostr(CheckInfo.Version);
   if (MinimalRuntime)
     FnName += "_minimal";
+  if (BelRuntime)
+    FnName += "_bel";
   if (NeedsAbortSuffix)
     FnName += "_abort";
   bool MayReturn =
       !IsFatal || RecoverKind == CheckRecoverableKind::AlwaysRecoverable;
 
   llvm::AttrBuilder B;
   if (!MayReturn) {
     B.addAttribute(llvm::Attribute::NoReturn)
#endif
   Branch->setMetadata(llvm::LLVMContext::MD_prof, Node);
   EmitBlock(Handlers);
 
   // Handler functions take an i8* pointing to the (handler-specific) static
   // information block, followed by a sequence of intptr_t arguments
   // representing operand values.
   SmallVector<llvm::Value *, 4> Args;
   SmallVector<llvm::Type *, 4> ArgTypes;
-  if (!CGM.getCodeGenOpts().SanitizeMinimalRuntime) {
+  if (!(CGM.getCodeGenOpts().SanitizeMinimalRuntime || CGM.getCodeGenOpts().SanitizeBelRuntime)) {
     Args.reserve(DynamicArgs.size() + 1);
     ArgTypes.reserve(DynamicArgs.size() + 1);
 
     // Emit handler arguments and create handler function type.
     if (!StaticArgs.empty()) {
       llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
       auto *InfoPtr =
           new llvm::GlobalVariable(CGM.getModule(), Info->getType(), false,

clang/lib/Driver/SanitizerArgs.cpp

static const SanitizerMask NeedsUbsanRt =
     SanitizerKind::Undefined | SanitizerKind::Integer |
     SanitizerKind::ImplicitConversion | SanitizerKind::Nullability |
     SanitizerKind::CFI | SanitizerKind::FloatDivideByZero;
 static const SanitizerMask NeedsUbsanCxxRt =
     SanitizerKind::Vptr | SanitizerKind::CFI;
 static const SanitizerMask NotAllowedWithTrap = SanitizerKind::Vptr;
 static const SanitizerMask NotAllowedWithMinimalRuntime =
     SanitizerKind::Function | SanitizerKind::Vptr;
+static const SanitizerMask NotAllowedWithBelRuntime =
+    SanitizerKind::Function | SanitizerKind::Vptr;
 static const SanitizerMask RequiresPIE =
     SanitizerKind::DataFlow | SanitizerKind::HWAddress | SanitizerKind::Scudo;
 static const SanitizerMask NeedsUnwindTables =
     SanitizerKind::Address | SanitizerKind::HWAddress | SanitizerKind::Thread |
     SanitizerKind::Memory | SanitizerKind::DataFlow;
 static const SanitizerMask SupportsCoverage =
     SanitizerKind::Address | SanitizerKind::HWAddress |
     SanitizerKind::KernelAddress | SanitizerKind::KernelHWAddress |
static const SanitizerMask TrappingSupported =
     SanitizerKind::CFI | SanitizerKind::FloatDivideByZero;
 static const SanitizerMask TrappingDefault = SanitizerKind::CFI;
 static const SanitizerMask CFIClasses =
     SanitizerKind::CFIVCall | SanitizerKind::CFINVCall |
     SanitizerKind::CFIMFCall | SanitizerKind::CFIDerivedCast |
     SanitizerKind::CFIUnrelatedCast;
 static const SanitizerMask CompatibleWithMinimalRuntime =
     TrappingSupported | SanitizerKind::Scudo | SanitizerKind::ShadowCallStack;
+static const SanitizerMask CompatibleWithBelRuntime =
+    TrappingSupported | SanitizerKind::Scudo | SanitizerKind::ShadowCallStack;
 
 enum CoverageFeature {
   CoverageFunc = 1 << 0,
   CoverageBB = 1 << 1,
   CoverageEdge = 1 << 2,
   CoverageIndirCall = 1 << 3,
   CoverageTraceBB = 1 << 4,  // Deprecated.
   CoverageTraceCmp = 1 << 5,
static SanitizerMask parseSanitizeTrapArgs(const Driver &D,
 
   return TrappingKinds;
 }
 
 bool SanitizerArgs::needsUbsanRt() const {
   // All of these include ubsan.
   if (needsAsanRt() || needsMsanRt() || needsHwasanRt() || needsTsanRt() ||
       needsDfsanRt() || needsLsanRt() || needsCfiDiagRt() ||
-      (needsScudoRt() && !requiresMinimalRuntime()))
+      (needsScudoRt() && !requiresMinimalRuntime() && !requiresBelRuntime()))
     return false;
 
   return (Sanitizers.Mask & NeedsUbsanRt & ~TrapSanitizers.Mask) ||
          CoverageFeatures;
 }
 
 bool SanitizerArgs::needsCfiRt() const {
   return !(Sanitizers.Mask & SanitizerKind::CFI & ~TrapSanitizers.Mask) &&
SanitizerArgs::SanitizerArgs(const ToolChain &TC,
   const Driver &D = TC.getDriver();
   SanitizerMask TrappingKinds = parseSanitizeTrapArgs(D, Args);
   SanitizerMask InvalidTrappingKinds = TrappingKinds & NotAllowedWithTrap;
 
   MinimalRuntime =
       Args.hasFlag(options::OPT_fsanitize_minimal_runtime,
                    options::OPT_fno_sanitize_minimal_runtime, MinimalRuntime);
 
+  BelRuntime =
+      Args.hasFlag(options::OPT_fsanitize_bel_runtime,
+                   options::OPT_fno_sanitize_bel_runtime, BelRuntime);
+
   // The object size sanitizer should not be enabled at -O0.
   Arg *OptLevel = Args.getLastArg(options::OPT_O_Group);
   bool RemoveObjectSizeAtO0 =
       !OptLevel || OptLevel->getOption().matches(options::OPT_O0);
 
   for (ArgList::const_reverse_iterator I = Args.rbegin(), E = Args.rend();
        I != E; ++I) {
     const auto *Arg = *I;
if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
           std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
           D.Diag(diag::err_drv_argument_not_allowed_with)
               << Desc << "-fsanitize-minimal-runtime";
           DiagnosedKinds |= KindsToDiagnose;
         }
         Add &= ~NotAllowedWithMinimalRuntime;
       }
 
+      if (BelRuntime) {
+        if (SanitizerMask KindsToDiagnose =
+                Add & NotAllowedWithBelRuntime & ~DiagnosedKinds) {
+          std::string Desc = describeSanitizeArg(*I, KindsToDiagnose);
+          D.Diag(diag::err_drv_argument_not_allowed_with)
+              << Desc << "-fsanitize-bel-runtime";
+          DiagnosedKinds |= KindsToDiagnose;
+        }
+        Add &= ~NotAllowedWithBelRuntime;
+      }
+
       // FIXME: Make CFI on member function calls compatible with cross-DSO CFI.
       // There are currently two problems:
       // - Virtual function call checks need to pass a pointer to the function
       //   address to llvm.type.test and a pointer to the address point to the
       //   diagnostic function. Currently we pass the same pointer to both
       //   places.
       // - Non-virtual function call checks may need to check multiple type
       //   identifiers.
if (Arg->getOption().matches(options::OPT_fsanitize_EQ)) {
       // Group expansion may have enabled a sanitizer which is disabled later.
       Add &= ~AllRemove;
       // Silently discard any unsupported sanitizers implicitly enabled through
       // group expansion.
       Add &= ~InvalidTrappingKinds;
       if (MinimalRuntime) {
         Add &= ~NotAllowedWithMinimalRuntime;
       }
+      if (BelRuntime) {
+        Add &= ~NotAllowedWithBelRuntime;
+      }
       if (CfiCrossDso)
         Add &= ~SanitizerKind::CFIMFCall;
       Add &= Supported;
 
       if (Add & SanitizerKind::Fuzzer)
         Add |= SanitizerKind::FuzzerNoLink;
 
       // Enable coverage if the fuzzing flag is set.
if (MinimalRuntime) {
 
     SanitizerMask NonTrappingCfi = Kinds & SanitizerKind::CFI & ~TrappingKinds;
     if (NonTrappingCfi)
       D.Diag(clang::diag::err_drv_argument_only_allowed_with)
           << "fsanitize-minimal-runtime"
           << "fsanitize-trap=cfi";
   }
 
+  if (BelRuntime) {
+    SanitizerMask IncompatibleMask =
+        Kinds & ~setGroupBits(CompatibleWithBelRuntime);
+    if (IncompatibleMask)
+      D.Diag(clang::diag::err_drv_argument_not_allowed_with)
+          << "-fsanitize-bel-runtime"
+          << lastArgumentForMask(D, Args, IncompatibleMask);
+
+    SanitizerMask NonTrappingCfi = Kinds & SanitizerKind::CFI & ~TrappingKinds;
+    if (NonTrappingCfi)
+      D.Diag(clang::diag::err_drv_argument_only_allowed_with)
+          << "fsanitize-bel-runtime"
+          << "fsanitize-trap=cfi";
+  }
+
   // Parse -f(no-)?sanitize-coverage flags if coverage is supported by the
   // enabled sanitizers.
   for (const auto *Arg : Args) {
     if (Arg->getOption().matches(options::OPT_fsanitize_coverage)) {
       int LegacySanitizeCoverage;
       if (Arg->getNumValues() == 1 &&
           !StringRef(Arg->getValue(0))
                .getAsInteger(0, LegacySanitizeCoverage)) {
if (CfiCanonicalJumpTables)
     CmdArgs.push_back("-fsanitize-cfi-canonical-jump-tables");
 
   if (Stats)
     CmdArgs.push_back("-fsanitize-stats");
 
   if (MinimalRuntime)
     CmdArgs.push_back("-fsanitize-minimal-runtime");
 
+  if (BelRuntime)
+    CmdArgs.push_back("-fsanitize-bel-runtime");
+
   if (AsanFieldPadding)
     CmdArgs.push_back(Args.MakeArgString("-fsanitize-address-field-padding=" +
                                          Twine(AsanFieldPadding)));
 
   if (AsanUseAfterScope)
     CmdArgs.push_back("-fsanitize-address-use-after-scope");
 
   if (AsanPoisonCustomArrayCookie)

clang/lib/Driver/ToolChains/CommonArgs.cpp

if (SanArgs.needsSharedRt()) {
     if (SanArgs.needsAsanRt() && SanArgs.linkRuntimes()) {
       SharedRuntimes.push_back("asan");
       if (!Args.hasArg(options::OPT_shared) && !TC.getTriple().isAndroid())
         HelperStaticRuntimes.push_back("asan-preinit");
     }
     if (SanArgs.needsUbsanRt() && SanArgs.linkRuntimes()) {
       if (SanArgs.requiresMinimalRuntime())
         SharedRuntimes.push_back("ubsan_minimal");
+      else if (SanArgs.requiresBelRuntime())
+        SharedRuntimes.push_back("ubsan_bel");
       else
         SharedRuntimes.push_back("ubsan_standalone");
     }
     if (SanArgs.needsScudoRt() && SanArgs.linkRuntimes()) {
       if (SanArgs.requiresMinimalRuntime())
         SharedRuntimes.push_back("scudo_minimal");
+      else if (SanArgs.requiresBelRuntime())
+        SharedRuntimes.push_back("scudo_bel");
       else
         SharedRuntimes.push_back("scudo");
     }
     if (SanArgs.needsHwasanRt() && SanArgs.linkRuntimes())
       SharedRuntimes.push_back("hwasan");
   }
 
   // The stats_client library is also statically linked into DSOs.
collectSanitizerRuntimes(const ToolChain &TC, const ArgList &Args,
   if (SanArgs.needsTsanRt() && SanArgs.linkRuntimes()) {
     StaticRuntimes.push_back("tsan");
     if (SanArgs.linkCXXRuntimes())
       StaticRuntimes.push_back("tsan_cxx");
   }
   if (!SanArgs.needsSharedRt() && SanArgs.needsUbsanRt() && SanArgs.linkRuntimes()) {
     if (SanArgs.requiresMinimalRuntime()) {
       StaticRuntimes.push_back("ubsan_minimal");
+    } else if (SanArgs.requiresBelRuntime()) {
+      StaticRuntimes.push_back("ubsan_bel");
     } else {
       StaticRuntimes.push_back("ubsan_standalone");
       if (SanArgs.linkCXXRuntimes())
         StaticRuntimes.push_back("ubsan_standalone_cxx");
     }
   }
   if (SanArgs.needsSafeStackRt() && SanArgs.linkRuntimes()) {
     NonWholeStaticRuntimes.push_back("safestack");
if (SanArgs.needsStatsRt() && SanArgs.linkRuntimes()) {
     NonWholeStaticRuntimes.push_back("stats");
     RequiredSymbols.push_back("__sanitizer_stats_register");
   }
   if (!SanArgs.needsSharedRt() && SanArgs.needsScudoRt() && SanArgs.linkRuntimes()) {
     if (SanArgs.requiresMinimalRuntime()) {
       StaticRuntimes.push_back("scudo_minimal");
       if (SanArgs.linkCXXRuntimes())
         StaticRuntimes.push_back("scudo_cxx_minimal");
+    } else if (SanArgs.requiresBelRuntime()) {
+      StaticRuntimes.push_back("scudo_bel");
+      if (SanArgs.linkCXXRuntimes())
+        StaticRuntimes.push_back("scudo_cxx_bel");
     } else {
       StaticRuntimes.push_back("scudo");
       if (SanArgs.linkCXXRuntimes())
         StaticRuntimes.push_back("scudo_cxx");
     }
   }
 }
 

clang/lib/Frontend/CompilerInvocation.cpp

Opts.SanitizeCoverageStackDepth =
       Args.hasArg(OPT_fsanitize_coverage_stack_depth);
   Opts.SanitizeMemoryTrackOrigins =
       getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
   Opts.SanitizeMemoryUseAfterDtor =
       Args.hasFlag(OPT_fsanitize_memory_use_after_dtor,
                    OPT_fno_sanitize_memory_use_after_dtor,
                    false);
   Opts.SanitizeMinimalRuntime = Args.hasArg(OPT_fsanitize_minimal_runtime);
+  Opts.SanitizeBelRuntime = Args.hasArg(OPT_fsanitize_bel_runtime);
   Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
   Opts.SanitizeCfiICallGeneralizePointers =
       Args.hasArg(OPT_fsanitize_cfi_icall_generalize_pointers);
   Opts.SanitizeCfiCanonicalJumpTables =
       Args.hasArg(OPT_fsanitize_cfi_canonical_jump_tables);
   Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
   if (Arg *A = Args.getLastArg(
           OPT_fsanitize_address_poison_custom_array_cookie,

clang/test/CodeGen/unsigned-overflow-bel.c

+// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsanitize=unsigned-integer-overflow -fsanitize-bel-runtime %s -emit-llvm -o - | FileCheck %s
+
+unsigned long li, lj, lk;
+
+// CHECK-LABEL: define void @testlongadd()
+void testlongadd() {
+  // CHECK: call void @__ubsan_handle_add_overflow_bel_abort()
+  li = lj + lk;
+}
+
+// CHECK-LABEL: define void @testlongsub()
+void testlongsub() {
+  // CHECK: call void @__ubsan_handle_sub_overflow_bel_abort()
+  li = lj - lk;
+}
+
+// CHECK-LABEL: define void @testlongmul()
+void testlongmul() {
+  // CHECK: call void @__ubsan_handle_mul_overflow_bel_abort()
+  li = lj * lk;
+}

clang/test/Driver/fsanitize.c

 // CHECK-CFI-NOICALL-MINIMAL: "-fsanitize=cfi-derived-cast,cfi-mfcall,cfi-unrelated-cast,cfi-nvcall,cfi-vcall"
 // CHECK-CFI-NOICALL-MINIMAL: "-fsanitize-trap=cfi-derived-cast,cfi-mfcall,cfi-unrelated-cast,cfi-nvcall,cfi-vcall"
 // CHECK-CFI-NOICALL-MINIMAL: "-fsanitize-minimal-runtime"
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=shadow-call-stack -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCS-MINIMAL
 // CHECK-SCS-MINIMAL: "-fsanitize=shadow-call-stack"
 // CHECK-SCS-MINIMAL: "-fsanitize-minimal-runtime"
 
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-BEL
+// CHECK-ASAN-BEL: error: invalid argument '-fsanitize-bel-runtime' not allowed with '-fsanitize=address'
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=thread -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-TSAN-BEL
+// CHECK-TSAN-BEL: error: invalid argument '-fsanitize-bel-runtime' not allowed with '-fsanitize=thread'
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN-BEL
+// CHECK-UBSAN-BEL: "-fsanitize={{((signed-integer-overflow|integer-divide-by-zero|shift-base|shift-exponent|unreachable|return|vla-bound|alignment|null|pointer-overflow|float-cast-overflow|array-bounds|enum|bool|builtin|returns-nonnull-attribute|nonnull-attribute),?){17}"}}
+// CHECK-UBSAN-BEL: "-fsanitize-bel-runtime"
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize=function -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN-FUNCTION-BEL
+// CHECK-UBSAN-FUNCTION-BEL: error: invalid argument '-fsanitize=function' not allowed with '-fsanitize-bel-runtime'
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -fsanitize=vptr -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-UBSAN-VPTR-BEL
+// CHECK-UBSAN-VPTR-BEL: error: invalid argument '-fsanitize=vptr' not allowed with '-fsanitize-bel-runtime'
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-bel-runtime -fsanitize=undefined %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ASAN-UBSAN-BEL
+// CHECK-ASAN-UBSAN-BEL: error: invalid argument '-fsanitize-bel-runtime' not allowed with '-fsanitize=address'
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=hwaddress -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-HWASAN-BEL
+// CHECK-HWASAN-BEL: error: invalid argument '-fsanitize-bel-runtime' not allowed with '-fsanitize=hwaddress'
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -flto -fvisibility=hidden -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-BEL
+// CHECK-CFI-BEL: "-fsanitize=cfi-derived-cast,cfi-icall,cfi-mfcall,cfi-unrelated-cast,cfi-nvcall,cfi-vcall"
+// CHECK-CFI-BEL: "-fsanitize-trap=cfi-derived-cast,cfi-icall,cfi-mfcall,cfi-unrelated-cast,cfi-nvcall,cfi-vcall"
+// CHECK-CFI-BEL: "-fsanitize-bel-runtime"
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -fno-sanitize-trap=cfi-icall -flto -fvisibility=hidden -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-NOTRAP-BEL
+// CHECK-CFI-NOTRAP-BEL: error: invalid argument 'fsanitize-bel-runtime' only allowed with 'fsanitize-trap=cfi'
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -fno-sanitize-trap=cfi-icall -fno-sanitize=cfi-icall -flto -fvisibility=hidden -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-CFI-NOICALL-BEL
+// CHECK-CFI-NOICALL-BEL: "-fsanitize=cfi-derived-cast,cfi-mfcall,cfi-unrelated-cast,cfi-nvcall,cfi-vcall"
+// CHECK-CFI-NOICALL-BEL: "-fsanitize-trap=cfi-derived-cast,cfi-mfcall,cfi-unrelated-cast,cfi-nvcall,cfi-vcall"
+// CHECK-CFI-NOICALL-BEL: "-fsanitize-bel-runtime"
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=shadow-call-stack -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCS-BEL
+// CHECK-SCS-BEL: "-fsanitize=shadow-call-stack"
+// CHECK-SCS-BEL: "-fsanitize-bel-runtime"
+
 // RUN: %clang -target aarch64-linux-gnu -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO
 // RUN: %clang -target arm-linux-androideabi -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO
 // RUN: %clang -target i386-linux-gnu -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO
 // RUN: %clang -target mips64-unknown-linux-gnu -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO
 // RUN: %clang -target mips64el-unknown-linux-gnu -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO
 // RUN: %clang -target mips-unknown-linux-gnu -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO
 // RUN: %clang -target mipsel-unknown-linux-gnu -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO

 // RUN: %clang -target x86_64-linux-gnu -fsanitize=scudo -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO-MINIMAL
 // CHECK-SCUDO-MINIMAL: "-fsanitize=scudo"
 // CHECK-SCUDO-MINIMAL: "-fsanitize-minimal-runtime"
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined,scudo -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO-UBSAN-MINIMAL
 // CHECK-SCUDO-UBSAN-MINIMAL: "-fsanitize={{.*}}scudo"
 // CHECK-SCUDO-UBSAN-MINIMAL: "-fsanitize-minimal-runtime"
 
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=scudo -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO-BEL
+// CHECK-SCUDO-BEL: "-fsanitize=scudo"
+// CHECK-SCUDO-BEL: "-fsanitize-bel-runtime"
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined,scudo -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO-UBSAN-BEL
+// CHECK-SCUDO-UBSAN-BEL: "-fsanitize={{.*}}scudo"
+// CHECK-SCUDO-UBSAN-BEL: "-fsanitize-bel-runtime"
+
 // RUN: %clang -target powerpc-unknown-linux -fsanitize=scudo %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SCUDO
 // CHECK-NO-SCUDO: unsupported option
 
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=scudo,address  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO-ASAN
 // CHECK-SCUDO-ASAN: error: invalid argument '-fsanitize=scudo' not allowed with '-fsanitize=address'
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=scudo,leak  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO-LSAN
 // CHECK-SCUDO-LSAN: error: invalid argument '-fsanitize=scudo' not allowed with '-fsanitize=leak'
 // RUN: %clang -target x86_64-linux-gnu -fsanitize=scudo,memory  %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-SCUDO-MSAN

 // CHECK-DIVBYZERO: "-fsanitize=float-divide-by-zero"
 // CHECK-DIVBYZERO-RECOVER: "-fsanitize-recover=float-divide-by-zero"
 // CHECK-DIVBYZERO-NORECOVER-NOT: "-fsanitize-recover=float-divide-by-zero"
 // CHECK-DIVBYZERO-TRAP: "-fsanitize-trap=float-divide-by-zero"
 
 // RUN: %clang -fsanitize=float-divide-by-zero -fsanitize-minimal-runtime %s -### 2>&1 | FileCheck %s --check-prefixes=CHECK-DIVBYZERO,CHECK-DIVBYZERO-MINIMAL
 // CHECK-DIVBYZERO-MINIMAL: "-fsanitize-minimal-runtime"
 
+// RUN: %clang -fsanitize=float-divide-by-zero -fsanitize-bel-runtime %s -### 2>&1 | FileCheck %s --check-prefixes=CHECK-DIVBYZERO,CHECK-DIVBYZERO-BEL
+// CHECK-DIVBYZERO-BEL: "-fsanitize-bel-runtime"
+
 // RUN: %clang -fsanitize=undefined,float-divide-by-zero %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DIVBYZERO-UBSAN
 // CHECK-DIVBYZERO-UBSAN: "-fsanitize={{.*}},float-divide-by-zero,{{.*}}"

clang/test/Driver/sanitizer-ld.c

 
 // RUN: %clang -fsanitize=undefined -fsanitize-minimal-runtime %s -### -o %t.o 2>&1 \
 // RUN:     -target x86_64-apple-darwin -fuse-ld=ld \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-UBSAN-MINIMAL-DARWIN %s
 // CHECK-UBSAN-MINIMAL-DARWIN: "{{.*}}ld{{(.exe)?}}"
 // CHECK-UBSAN-MINIMAL-DARWIN: "{{.*}}libclang_rt.ubsan_minimal_osx_dynamic.dylib"
 
+// RUN: %clang -fsanitize=undefined -fsanitize-bel-runtime %s -### -o %t.o 2>&1 \
+// RUN:     -target i386-unknown-linux -fuse-ld=ld \
+// RUN:     --sysroot=%S/Inputs/basic_linux_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-UBSAN-BEL-LINUX %s
+// CHECK-UBSAN-BEL-LINUX: "{{.*}}ld{{(.exe)?}}"
+// CHECK-UBSAN-BEL-LINUX: "--whole-archive" "{{.*}}libclang_rt.ubsan_bel-i386.a" "--no-whole-archive"
+// CHECK-UBSAN-BEL-LINUX: "-lpthread"
+
+// RUN: %clang -fsanitize=undefined -fsanitize-bel-runtime %s -### -o %t.o 2>&1 \
+// RUN:     -target x86_64-apple-darwin -fuse-ld=ld \
+// RUN:     --sysroot=%S/Inputs/basic_linux_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-UBSAN-BEL-DARWIN %s
+// CHECK-UBSAN-BEL-DARWIN: "{{.*}}ld{{(.exe)?}}"
+// CHECK-UBSAN-BEL-DARWIN: "{{.*}}libclang_rt.ubsan_bel_osx_dynamic.dylib"
+
 // RUN: %clang -fsanitize=undefined %s -### -o %t.o 2>&1 \
 // RUN:     -target x86_64-apple-darwin -fuse-ld=ld -static-libsan \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-UBSAN-STATIC-DARWIN %s
 // CHECK-UBSAN-STATIC-DARWIN: "{{.*}}ld{{(.exe)?}}"
 // CHECK-UBSAN-STATIC-DARWIN: "{{.*}}libclang_rt.ubsan_osx.a"
 
 // RUN: %clang -fsanitize=address,undefined %s -### -o %t.o 2>&1 \

 // RUN:     -target i386-unknown-linux -fuse-ld=ld \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-SCUDO-MINIMAL-LINUX %s
 // CHECK-SCUDO-MINIMAL-LINUX: "{{.*}}ld{{(.exe)?}}"
 // CHECK-SCUDO-MINIMAL-LINUX: "-pie"
 // CHECK-SCUDO-MINIMAL-LINUX: "--whole-archive" "{{.*}}libclang_rt.scudo_minimal-i386.a" "--no-whole-archive"
 // CHECK-SCUDO-MINIMAL-LINUX: "-lpthread"
 
+// RUN: %clang -fsanitize=scudo -fsanitize-bel-runtime %s -### -o %t.o 2>&1 \
+// RUN:     -target i386-unknown-linux -fuse-ld=ld \
+// RUN:     --sysroot=%S/Inputs/basic_linux_tree \
+// RUN:   | FileCheck --check-prefix=CHECK-SCUDO-BEL-LINUX %s
+// CHECK-SCUDO-BEL-LINUX: "{{.*}}ld{{(.exe)?}}"
+// CHECK-SCUDO-BEL-LINUX: "-pie"
+// CHECK-SCUDO-BEL-LINUX: "--whole-archive" "{{.*}}libclang_rt.scudo_bel-i386.a" "--no-whole-archive"
+// CHECK-SCUDO-BEL-LINUX: "-lpthread"
+
 // RUN: %clang -no-canonical-prefixes %s -### -o %t.so -shared 2>&1 \
 // RUN:     -target i386-unknown-linux -fuse-ld=ld -fsanitize=scudo -shared-libsan \
 // RUN:     -resource-dir=%S/Inputs/resource_dir \
 // RUN:     --sysroot=%S/Inputs/basic_linux_tree \
 // RUN:   | FileCheck --check-prefix=CHECK-SCUDO-SHARED-LINUX %s
 //
 // CHECK-SCUDO-SHARED-LINUX: "{{(.*[^-.0-9A-Z_a-z])?}}ld{{(.exe)?}}"
 // CHECK-SCUDO-SHARED-LINUX-NOT: "-lc"

compiler-rt/cmake/config-ix.cmake

 
 find_program(GOLD_EXECUTABLE NAMES ${LLVM_DEFAULT_TARGET_TRIPLE}-ld.gold ld.gold ${LLVM_DEFAULT_TARGET_TRIPLE}-ld ld DOC "The gold linker")
 
 if(COMPILER_RT_SUPPORTED_ARCH)
   list(REMOVE_DUPLICATES COMPILER_RT_SUPPORTED_ARCH)
 endif()
 message(STATUS "Compiler-RT supported architectures: ${COMPILER_RT_SUPPORTED_ARCH}")
 
-set(ALL_SANITIZERS asan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo;ubsan_minimal;gwp_asan)
+set(ALL_SANITIZERS asan;dfsan;msan;hwasan;tsan;safestack;cfi;scudo;ubsan_minimal;ubsan_bel;gwp_asan)
 set(COMPILER_RT_SANITIZERS_TO_BUILD all CACHE STRING
     "sanitizers to build if supported on the target (all;${ALL_SANITIZERS})")
 list_replace(COMPILER_RT_SANITIZERS_TO_BUILD all "${ALL_SANITIZERS}")
 
 if (SANITIZER_COMMON_SUPPORTED_ARCH AND NOT LLVM_USE_SANITIZER AND
     (OS_NAME MATCHES "Android|Darwin|Linux|FreeBSD|NetBSD|OpenBSD|Fuchsia|SunOS" OR
     (OS_NAME MATCHES "Windows" AND NOT CYGWIN AND
         (NOT MINGW OR CMAKE_CXX_COMPILER_ID MATCHES "Clang"))))
if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
   set(COMPILER_RT_HAS_UBSAN TRUE)
 else()
   set(COMPILER_RT_HAS_UBSAN FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND UBSAN_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|FreeBSD|NetBSD|OpenBSD|Android|Darwin")
   set(COMPILER_RT_HAS_UBSAN_MINIMAL TRUE)
+  set(COMPILER_RT_HAS_UBSAN_BEL TRUE)
 else()
   set(COMPILER_RT_HAS_UBSAN_MINIMAL FALSE)
+  set(COMPILER_RT_HAS_UBSAN_BEL FALSE)
 endif()
 
 if (COMPILER_RT_HAS_SANITIZER_COMMON AND SAFESTACK_SUPPORTED_ARCH AND
     OS_NAME MATCHES "Linux|FreeBSD|NetBSD")
   set(COMPILER_RT_HAS_SAFESTACK TRUE)
 else()
   set(COMPILER_RT_HAS_SAFESTACK FALSE)
 endif()

compiler-rt/lib/ubsan_bel/CMakeLists.txt

+# Build for the bel undefined behavior sanitizer runtime support library.
+
+set(UBSAN_BEL_SOURCES
+  ubsan_bel_handlers.cpp
+  )
+
+include_directories(..)
+
+set(UBSAN_CFLAGS ${SANITIZER_COMMON_CFLAGS})
+append_rtti_flag(OFF UBSAN_CFLAGS)
+
+set(UBSAN_LINK_FLAGS ${SANITIZER_COMMON_LINK_FLAGS})
+
+set(UBSAN_DYNAMIC_LIBS ${SANITIZER_COMMON_LINK_LIBS})
+
+add_compiler_rt_component(ubsan-bel)
+
+# Common parts of bel UBSan runtime.
+add_compiler_rt_object_libraries(RTUbsan_bel
+  OS ${SANITIZER_COMMON_SUPPORTED_OS}
+  ARCHS ${UBSAN_COMMON_SUPPORTED_ARCH}
+  SOURCES ${UBSAN_BEL_SOURCES} CFLAGS ${UBSAN_CFLAGS})
+
+
+if(COMPILER_RT_HAS_UBSAN_BEL)
+  # Standalone bel UBSan runtimes.
+  add_compiler_rt_runtime(clang_rt.ubsan_bel
+    STATIC
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${UBSAN_SUPPORTED_ARCH}
+    OBJECT_LIBS RTUbsan_bel
+    CFLAGS ${UBSAN_CFLAGS}
+    PARENT_TARGET ubsan-bel)
+
+  add_compiler_rt_runtime(clang_rt.ubsan_bel
+    SHARED
+    OS ${SANITIZER_COMMON_SUPPORTED_OS}
+    ARCHS ${UBSAN_SUPPORTED_ARCH}
+    OBJECT_LIBS RTUbsan_bel
+    CFLAGS ${UBSAN_CFLAGS}
+    LINK_FLAGS ${UBSAN_LINK_FLAGS}
+    LINK_LIBS ${UBSAN_DYNAMIC_LIBS}
+    PARENT_TARGET ubsan-bel)
+
+  if (SANITIZER_USE_SYMBOLS AND NOT APPLE)
+    set(ARCHS_FOR_SYMBOLS ${UBSAN_SUPPORTED_ARCH})
+    list(REMOVE_ITEM ARCHS_FOR_SYMBOLS i386 i686)
+    add_sanitizer_rt_symbols(clang_rt.ubsan_bel
+      ARCHS ${ARCHS_FOR_SYMBOLS}
+      PARENT_TARGET ubsan-bel
+      EXTRA ubsan.syms.extra)
+  endif()
+endif()

compiler-rt/lib/ubsan_bel/ubsan.syms.extra

+__ubsan_*

compiler-rt/lib/ubsan_bel/ubsan_bel_handlers.cpp

+//===-- ubsan_bel_handlers.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
+//
+//===----------------------------------------------------------------------===//
+//
+// Entry points for the UBSan ␇ runtime.
+//
+//===----------------------------------------------------------------------===//
+
+#include "sanitizer_common/sanitizer_atomic.h"
+#include "sanitizer_common/sanitizer_platform.h"
+
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <unistd.h>
+#include <random>
+
+static void message(const char *msg, void *address = nullptr) {
+#if SANITIZER_MAC
+  auto quip = []() {
+    static const char *quips[] = {
+      "I'm so sorry",
+      "Maybe running the program again will avoid the problem next time",
+      "That sounds pretty bad",
+      "This must have hurt",
+      "Please stop",
+      "Did you have to?",
+      "I bet you didn't know this particular thing was undefined!",
+      "Why would you even do this?",
+      "Wow, that was a sweet jump!",
+      "This Is Just To Say: I have optimized out the statements that were in the program and which you were probably saving for correctness. Forgive me, they were delicious. So undefined, and so fast",
+      "Now go away or I shall taunt you a second time",
+      "Explain to me again how sheep's bladders may be employed to prevent earthquakes",
+      "You sons of silly persons",
+    };
+    static std::random_device r;
+    static std::default_random_engine e(r());
+    static std::uniform_int_distribution<int> d(0, sizeof(quips) / sizeof(quips[0]) - 1);
+    return quips[d(e)];
+  };
+  char buf[2048] = { '\0' };
+  size_t pos = 0;
+  const size_t end = sizeof(buf) / sizeof(buf[0]) - 1;
+  auto cp = [&] (const char *what) {
+    while (*what && pos < end)
+      buf[pos++] = *what++;
+  };
+  cp("say \"Undefined Behavior ");
+  cp(msg);
+  if (address && (pos + 28 < end)) {
+    cp(" at address ");
+    pos += sprintf(&buf[pos], "%16llx", (uint64_t)address);
+  }
+  cp("... ");
+  cp(quip());
+  cp("\"");
+  system(buf);
+#else
+  // Plain Old Bell (POB).
+  (void)msg;
+  write(2, "\a", strlen("\a"));
+#endif
+}
+
+static const int kMaxCallerPcs = 20;
+static __sanitizer::atomic_uintptr_t caller_pcs[kMaxCallerPcs];
+static __sanitizer::atomic_uint32_t caller_pcs_sz;
+
+__attribute__((noinline)) static bool report_this_error(void *caller_p) {
+  uintptr_t caller = reinterpret_cast<uintptr_t>(caller_p);
+  if (caller == 0) return false;
+  while (true) {
+    unsigned sz = __sanitizer::atomic_load_relaxed(&caller_pcs_sz);
+    if (sz > kMaxCallerPcs) return false;
+    if (sz > 0 && sz < kMaxCallerPcs) {
+      uintptr_t p;
+      for (unsigned i = 0; i < sz; ++i) {
+        p = __sanitizer::atomic_load_relaxed(&caller_pcs[i]);
+        if (p == 0) break;  // Concurrent update.
+        if (p == caller) return false;
+      }
+      if (p == 0) continue;
+    }
+
+    if (!__sanitizer::atomic_compare_exchange_strong(
+            &caller_pcs_sz, &sz, sz + 1, __sanitizer::memory_order_seq_cst))
+      continue;
+
+    if (sz == kMaxCallerPcs) {
+      message("is over 9000, there's no way that could be right");
+#if SANITIZER_MAC
+      system("open https://www.youtube.com/watch?v=SiMHTK15Pik");
+#endif
+      return false;
+    }
+    __sanitizer::atomic_store_relaxed(&caller_pcs[sz], caller);
+    return true;
+  }
+}
+
+#if SANITIZER_DEBUG
+namespace __sanitizer {
+// The DCHECK macro needs this symbol to be defined.
+void NORETURN CheckFailed(const char *file, int, const char *cond, u64, u64) {
+  message("Sanitizer CHECK failed: ");
+  message(file);
+  message(":?? : "); // FIXME: Show line number.
+  message(cond);
+  abort();
+}
+} // namespace __sanitizer
+#endif
+
+#define INTERFACE extern "C" __attribute__((visibility("default")))
+
+#define HANDLER_RECOVER(name, msg)                               \
+  INTERFACE void __ubsan_handle_##name##_bel() {                 \
+    if (!report_this_error(__builtin_return_address(0))) return; \
+    message(msg, __builtin_return_address(0));                   \
+  }
+
+#define HANDLER_NORECOVER(name, msg)                             \
+  INTERFACE void __ubsan_handle_##name##_bel_abort() {           \
+    message(msg, __builtin_return_address(0));                   \
+    abort();                                                     \
+  }
+
+#define HANDLER(name, msg)                                       \
+  HANDLER_RECOVER(name, msg)                                     \
+  HANDLER_NORECOVER(name, msg)
+
+HANDLER(type_mismatch, "type mismatch")
+HANDLER(alignment_assumption, "alignment assumption")
+HANDLER(add_overflow, "add overflow")
+HANDLER(sub_overflow, "subtraction overflow")
+HANDLER(mul_overflow, "multiplication overflow")
+HANDLER(negate_overflow, "negate overflow")
+HANDLER(divrem_overflow, "divrem overflow")
+HANDLER(shift_out_of_bounds, "shift out of bounds")
+HANDLER(out_of_bounds, "out of bounds")
+HANDLER_RECOVER(builtin_unreachable, "builtin unreachable")
+HANDLER_RECOVER(missing_return, "missing return")
+HANDLER(vla_bound_not_positive, "variable length array bound not positive")
+HANDLER(float_cast_overflow, "float cast overflow")
+HANDLER(load_invalid_value, "load invalid value")
+HANDLER(invalid_builtin, "invalid builtin")
+HANDLER(function_type_mismatch, "function type mismatch")
+HANDLER(implicit_conversion, "implicit conversion")
+HANDLER(nonnull_arg, "non-null argument")
+HANDLER(nonnull_return, "non-null return")
+HANDLER(nullability_arg, "nullability argument")
+HANDLER(nullability_return, "nullability return")
+HANDLER(pointer_overflow, "pointer overflow")
+HANDLER(cfi_check_fail, "control flow integrity check fail")

compiler-rt/test/ubsan_bel/CMakeLists.txt

+set(UBSAN_LIT_TESTS_DIR ${CMAKE_CURRENT_SOURCE_DIR})
+
+set(UBSAN_TEST_ARCH ${UBSAN_SUPPORTED_ARCH})
+if(APPLE)
+  darwin_filter_host_archs(UBSAN_SUPPORTED_ARCH UBSAN_TEST_ARCH)
+endif()
+
+set(UBSAN_TESTSUITES)
+set(UBSAN_TEST_DEPS ${SANITIZER_COMMON_LIT_TEST_DEPS})
+if(NOT COMPILER_RT_STANDALONE_BUILD)
+  list(APPEND UBSAN_TEST_DEPS ubsan-bel)
+endif()
+
+foreach(arch ${UBSAN_TEST_ARCH})
+  get_test_cc_for_arch(${arch} UBSAN_TEST_TARGET_CC UBSAN_TEST_TARGET_CFLAGS)
+  set(CONFIG_NAME ${arch})
+  configure_lit_site_cfg(
+    ${CMAKE_CURRENT_SOURCE_DIR}/lit.site.cfg.py.in
+    ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME}/lit.site.cfg.py)
+  list(APPEND UBSAN_TESTSUITES ${CMAKE_CURRENT_BINARY_DIR}/${CONFIG_NAME})
+endforeach()
+
+add_lit_testsuite(check-ubsan-bel "Running UndefinedBehaviorSanitizerBel tests"
+  ${UBSAN_TESTSUITES}
+  DEPENDS ${UBSAN_TEST_DEPS})
+set_target_properties(check-ubsan-bel PROPERTIES FOLDER "Compiler-RT Misc")

compiler-rt/test/ubsan_bel/TestCases/alignment-assumption.c

+// RUN: %clang -fsanitize=alignment %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
+
+#include <stdlib.h>
+
+int main(int argc, char* argv[]) {
+// CHECK-NOT: alignment-assumption
+
+char *ptr = (char *)malloc(2);
+
+__builtin_assume_aligned(ptr + 1, 0x8000);
+// CHECK: alignment-assumption
+// CHECK-NOT: alignment-assumption
+
+free(ptr);
+
+return 0;
+}

compiler-rt/test/ubsan_bel/TestCases/implicit-integer-sign-change.c

+// RUN: %clang -fsanitize=implicit-integer-sign-change %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
+
+#include <stdint.h>
+
+int main() {
+// CHECK-NOT: implicit-conversion
+
+  // Explicitly casting hides it,
+  int32_t n0 = (int32_t)(~((uint32_t)0));
+
+  // Positive tests.
+  int32_t t0 = (~((uint32_t)0));
+// CHECK: implicit-conversion
+// CHECK-NOT: implicit-conversion
+
+  return 0;
+}

compiler-rt/test/ubsan_bel/TestCases/implicit-signed-integer-truncation-or-sign-change.c

+// RUN: %clang -fsanitize=implicit-signed-integer-truncation,implicit-integer-sign-change %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
+
+#include <stdint.h>
+
+int main() {
+// CHECK-NOT: implicit-conversion
+
+  // Explicitly casting hides it,
+  int8_t n0 = (int8_t)((uint32_t)-1);
+
+  // Positive tests.
+  int8_t t0 = (uint32_t)-1;
+// CHECK: implicit-conversion
+// CHECK-NOT: implicit-conversion
+
+  return 0;
+}

compiler-rt/test/ubsan_bel/TestCases/implicit-signed-integer-truncation.c

+// RUN: %clang -fsanitize=implicit-signed-integer-truncation %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
+
+#include <stdint.h>
+
+int main() {
+// CHECK-NOT: implicit-conversion
+
+  // Negative tests. Even if they produce unexpected results, this sanitizer does not care.
+  int8_t n0 = (~((uint32_t)(0))); // ~0 -> -1, but do not warn.
+  uint8_t n2 = 128;
+  uint8_t n3 = 255;
+  // Bools do not count
+  _Bool b0 = (~((uint32_t)(0)));
+  _Bool b1 = 255;
+
+  // Explicit and-ing of bits will silence it.
+  uint8_t nc0 = ((int32_t)(-1)) & 255;
+
+  // Positive tests.
+  uint8_t t0 = (int32_t)(-1);
+// CHECK: implicit-conversion
+// CHECK-NOT: implicit-conversion
+
+  return 0;
+}

compiler-rt/test/ubsan_bel/TestCases/implicit-unsigned-integer-truncation.c

+// RUN: %clang -fsanitize=implicit-unsigned-integer-truncation %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK
+
+#include <stdint.h>
+
+int main() {
+// CHECK-NOT: implicit-conversion
+
+  // Negative tests. Even if they produce unexpected results, this sanitizer does not care.
+  int8_t n0 = (~((uint32_t)(0))); // ~0 -> -1, but do not warn.
+  uint8_t n2 = 128;
+  uint8_t n3 = 255;
+  // Bools do not count
+  _Bool b0 = (~((uint32_t)(0)));
+  _Bool b1 = 255;
+
+  // Explicit and-ing of bits will silence it.
+  uint8_t nc0 = ((~((uint32_t)(0))) & 255);
+
+  // Positive tests.
+  uint8_t t0 = (~((uint32_t)(0)));
+// CHECK: implicit-conversion
+// CHECK-NOT: implicit-conversion
+
+  return 0;
+}

compiler-rt/test/ubsan_bel/TestCases/nullptr-and-nonzero-offset.c

+// RUN: %clang   -fsanitize=pointer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-C --implicit-check-not="pointer-overflow"
+// RUN: %clangxx -fsanitize=pointer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s --check-prefixes=CHECK,CHECK-CPP --implicit-check-not="pointer-overflow"
+
+#include <stdlib.h>
+
+int main(int argc, char *argv[]) {
+  char *base, *result;
+
+  base = (char *)0;
+  result = base + 0;
+  // CHECK-C: pointer-overflow
+
+  base = (char *)0;
+  result = base + 1;
+  // CHECK: pointer-overflow
+
+  base = (char *)1;
+  result = base - 1;
+  // CHECK: pointer-overflow
+
+  return 0;
+}

compiler-rt/test/ubsan_bel/TestCases/recover-dedup-limit.cpp

+// RUN: %clangxx -fsanitize=signed-integer-overflow -fsanitize-recover=all %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdint.h>
+
+#define OVERFLOW  \
+  x = 0x7FFFFFFE; \
+  x += __LINE__
+
+int main() {
+  int32_t x;
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+  OVERFLOW;  // CHECK: add-overflow
+
+  // CHECK-NOT: add-overflow
+  OVERFLOW;  // CHECK: too many errors
+  // CHECK-NOT: add-overflow
+  OVERFLOW;
+  OVERFLOW;
+  OVERFLOW;
+}

compiler-rt/test/ubsan_bel/TestCases/recover-dedup.cpp

+// RUN: %clangxx -w -fsanitize=signed-integer-overflow,nullability-return,returns-nonnull-attribute -fsanitize-recover=all %s -o %t && %run %t 2>&1 | FileCheck %s
+
+#include <stdint.h>
+#include <stdio.h>
+
+int *_Nonnull h() {
+  // CHECK: nullability-return
+  return NULL;
+}
+
+__attribute__((returns_nonnull))
+int *i() {
+  // CHECK: nonnull-return
+  return NULL;
+}
+
+__attribute__((noinline))
+int f(int x, int y) {
+  // CHECK: mul-overflow
+  return x * y;
+}
+
+__attribute__((noinline))
+int g(int x, int y) {
+  // CHECK: mul-overflow
+  return x * (y + 1);
+}
+
+int main() {
+  h();
+  i();
+  int x = 2;
+  for (int i = 0; i < 10; ++i)
+    x = f(x, x);
+  x = 2;
+  for (int i = 0; i < 10; ++i)
+    x = g(x, x);
+  // CHECK-NOT: mul-overflow
+}

compiler-rt/test/ubsan_bel/TestCases/test-darwin-interface.c

+// Check that the ubsan and ubsan-minimal runtimes have the same symbols,
+// making exceptions as necessary.
+//
+// REQUIRES: x86_64-darwin
+
+// RUN: nm -jgU `%clangxx -fsanitize-minimal-runtime -fsanitize=undefined %s -o %t '-###' 2>&1 | grep "libclang_rt.ubsan_minimal_osx_dynamic.dylib" | sed -e 's/.*"\(.*libclang_rt.ubsan_minimal_osx_dynamic.dylib\)".*/\1/'` | grep "^___ubsan_handle" \
+// RUN:  | sed 's/_minimal//g' \
+// RUN:  > %t.minimal.symlist
+//
+// RUN: nm -jgU `%clangxx -fno-sanitize-minimal-runtime -fsanitize=undefined %s -o %t '-###' 2>&1 | grep "libclang_rt.ubsan_osx_dynamic.dylib" | sed -e 's/.*"\(.*libclang_rt.ubsan_osx_dynamic.dylib\)".*/\1/'` | grep "^___ubsan_handle" \
+// RUN:  | grep -vE "^___ubsan_handle_dynamic_type_cache_miss" \
+// RUN:  | grep -vE "^___ubsan_handle_cfi_bad_type" \
+// RUN:  | sed 's/_v1//g' \
+// RUN:  > %t.full.symlist
+//
+// RUN: diff %t.minimal.symlist %t.full.symlist

compiler-rt/test/ubsan_bel/TestCases/uadd-overflow.cpp

+// RUN: %clangxx -fsanitize=unsigned-integer-overflow %s -o %t && %run %t 2>&1 | FileCheck %s
+// RUN: %clangxx -fsanitize=unsigned-integer-overflow -fno-sanitize-recover=all %s -o %t && not --crash %run %t 2>&1 | FileCheck %s
+
+#include <stdint.h>
+
+int main() {
+  uint32_t k = 0x87654321;
+  k += 0xedcba987;
+  // CHECK: add-overflow
+}

compiler-rt/test/ubsan_bel/lit.common.cfg.py

+# -*- Python -*-
+
+import os
+
+def get_required_attr(config, attr_name):
+  attr_value = getattr(config, attr_name, None)
+  if attr_value == None:
+    lit_config.fatal(
+      "No attribute %r in test configuration! You may need to run "
+      "tests from your build directory or add this attribute "
+      "to lit.site.cfg.py " % attr_name)
+  return attr_value
+
+# Setup source root.
+config.test_source_root = os.path.dirname(__file__)
+config.name = 'UBSan-Bel-' + config.target_arch
+
+def build_invocation(compile_flags):
+  return " " + " ".join([config.clang] + compile_flags) + " "
+
+target_cflags = [get_required_attr(config, "target_cflags")]
+clang_ubsan_cflags = ["-fsanitize-bel-runtime"] + target_cflags
+clang_ubsan_cxxflags = config.cxx_mode_flags + clang_ubsan_cflags
+
+# Define %clang and %clangxx substitutions to use in test RUN lines.
+config.substitutions.append( ("%clang ", build_invocation(clang_ubsan_cflags)) )
+config.substitutions.append( ("%clangxx ", build_invocation(clang_ubsan_cxxflags)) )
+
+# Default test suffixes.
+config.suffixes = ['.c', '.cpp']
+
+# Check that the host supports UndefinedBehaviorSanitizerBel tests
+if config.host_os not in ['Linux', 'FreeBSD', 'NetBSD', 'Darwin', 'OpenBSD']: # TODO: Windows
+  config.unsupported = True
+
+# Don't target x86_64h if the test machine can't execute x86_64h binaries.
+if '-arch x86_64h' in target_cflags and 'x86_64h' not in config.available_features:
+  config.unsupported = True
+
+config.available_features.add('arch=' + config.target_arch)

compiler-rt/test/ubsan_bel/lit.site.cfg.py.in

+@LIT_SITE_CFG_IN_HEADER@
+
+# Tool-specific config options.
+config.target_cflags = "@UBSAN_TEST_TARGET_CFLAGS@"
+config.target_arch = "@UBSAN_TEST_TARGET_ARCH@"
+
+# Load common config for all compiler-rt lit tests.
+lit_config.load_config(config, "@COMPILER_RT_BINARY_DIR@/test/lit.common.configured")
+
+# Load tool-specific config that would do the real work.
+lit_config.load_config(config, "@UBSAN_LIT_TESTS_DIR@/lit.common.cfg.py")