Added initial configuration for BSAN.

icmccorm · icmccorm · commit 311c327462fa · 2024-11-22T15:01:27.000-05:00
Specified bsan branch of LLVM submodule.

Added Borrow sanitizer options to frontend.

Added additional configuration flags for BSAN.

Updated llvm submodule and ensured that retags are allowed in subsequent MIR passes.

Updated LLVM project.
diff --git a/.github/workflows/sync.yml b/.github/workflows/sync.yml
@@ -0,0 +1,27 @@
+name: sync
+on: workflow_dispatch
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+defaults:
+  run:
+    shell: bash
+concurrency:
+  group: "sync"
+  cancel-in-progress: true
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Identity
+        run: |
+          git config --global user.name "github-actions[bot]"
+          git config --global user.email "github-actions[bot]@users.noreply.github.com"
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Rebase
+        run: src/ci/scripts/sync.sh
+      - name: Build
+        run: ./x.py build --stage 1 library
diff --git a/.gitmodules b/.gitmodules
@@ -54,4 +54,4 @@
 [submodule "src/gcc"]
 	path = src/gcc
 	url = https://github.com/rust-lang/gcc.git
-	shallow = true
+	shallow = true
diff --git a/Cargo.lock b/Cargo.lock
@@ -289,6 +289,10 @@ dependencies = [
  "generic-array",
 ]
 
+[[package]]
+name = "bsan"
+version = "0.1.0"
+
 [[package]]
 name = "bstr"
 version = "1.10.0"
diff --git a/Cargo.toml b/Cargo.toml
@@ -8,6 +8,8 @@ members = [
   "src/rustc-std-workspace/rustc-std-workspace-alloc",
   "src/rustc-std-workspace/rustc-std-workspace-std",
   "src/rustdoc-json-types",
+  "src/tools/bsan",
+  "src/tools/build_helper",
   "src/tools/cargotest",
   "src/tools/clippy",
   "src/tools/clippy/clippy_dev",
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
@@ -664,8 +664,12 @@ impl<'a, 'tcx> ResultsVisitor<'a, 'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<
                     state,
                 );
             }
+            StatementKind::Retag { .. } => {
+                if !self.infcx.tcx.sess.emit_retags() {
+                    bug!("Statement not allowed in this MIR phase")
+                }
+            }
             StatementKind::Nop
-            | StatementKind::Retag { .. }
             | StatementKind::Deinit(..)
             | StatementKind::SetDiscriminant { .. } => {
                 bug!("Statement not allowed in this MIR phase")
@@ -1779,11 +1783,11 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                 mpi,
             );
         } // Only query longest prefix with a MovePath, not further
-        // ancestors; dataflow recurs on children when parents
-        // move (to support partial (re)inits).
-        //
-        // (I.e., querying parents breaks scenario 7; but may want
-        // to do such a query based on partial-init feature-gate.)
+          // ancestors; dataflow recurs on children when parents
+          // move (to support partial (re)inits).
+          //
+          // (I.e., querying parents breaks scenario 7; but may want
+          // to do such a query based on partial-init feature-gate.)
     }
 
     /// Subslices correspond to multiple move paths, so we iterate through the
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -1245,10 +1245,14 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                     "Unexpected NonDivergingIntrinsic::CopyNonOverlapping, should only appear after lowering_intrinsics",
                 ),
             },
+            StatementKind::Retag { .. } => {
+                if !self.infcx.tcx.sess.emit_retags() {
+                    bug!("Statement not allowed in this MIR phase")
+                }
+            },
             StatementKind::FakeRead(..)
             | StatementKind::StorageLive(..)
             | StatementKind::StorageDead(..)
-            | StatementKind::Retag { .. }
             | StatementKind::Coverage(..)
             | StatementKind::ConstEvalCounter
             | StatementKind::PlaceMention(..)
diff --git a/compiler/rustc_codegen_llvm/src/attributes.rs b/compiler/rustc_codegen_llvm/src/attributes.rs
@@ -114,6 +114,9 @@ pub(crate) fn sanitize_attrs<'ll>(
     if enabled.contains(SanitizerSet::SAFESTACK) {
         attrs.push(llvm::AttributeKind::SanitizeSafeStack.create_attr(cx.llcx));
     }
+    if enabled.contains(SanitizerSet::BORROW) {
+        attrs.push(llvm::AttributeKind::SanitizeBorrow.create_attr(cx.llcx));
+    }
     attrs
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -553,6 +553,7 @@ pub(crate) unsafe fn llvm_optimize(
             sanitize_kernel_address_recover: config
                 .sanitizer_recover
                 .contains(SanitizerSet::KERNELADDRESS),
+            sanitize_borrow: config.sanitizer.contains(SanitizerSet::BORROW),
         })
     } else {
         None
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -252,6 +252,7 @@ pub enum AttributeKind {
     FnRetThunkExtern = 41,
     Writable = 42,
     DeadOnUnwind = 43,
+    SanitizeBorrow = 44,
 }
 
 /// LLVMIntPredicate
@@ -541,6 +542,7 @@ pub struct SanitizerOptions {
     pub sanitize_hwaddress_recover: bool,
     pub sanitize_kernel_address: bool,
     pub sanitize_kernel_address_recover: bool,
+    pub sanitize_borrow: bool,
 }
 
 /// LLVMRelocMode
diff --git a/compiler/rustc_codegen_llvm/src/retag.rs b/compiler/rustc_codegen_llvm/src/retag.rs
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1315,6 +1315,9 @@ fn add_sanitizer_libraries(
     if sanitizer.contains(SanitizerSet::ADDRESS) {
         link_sanitizer_runtime(sess, flavor, linker, "asan");
     }
+    if sanitizer.contains(SanitizerSet::BORROW) {
+        link_sanitizer_runtime(sess, flavor, linker, "bsan");
+    }
     if sanitizer.contains(SanitizerSet::DATAFLOW) {
         link_sanitizer_runtime(sess, flavor, linker, "dfsan");
     }
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -337,6 +337,10 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                                 codegen_fn_attrs.no_sanitize |=
                                     SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS
                             }
+                            sym::borrow => {
+                                codegen_fn_attrs.no_sanitize |=
+                                    SanitizerSet::BORROW
+                            }
                             sym::cfi => codegen_fn_attrs.no_sanitize |= SanitizerSet::CFI,
                             sym::kcfi => codegen_fn_attrs.no_sanitize |= SanitizerSet::KCFI,
                             sym::memory => codegen_fn_attrs.no_sanitize |= SanitizerSet::MEMORY,
diff --git a/compiler/rustc_codegen_ssa/src/mir/statement.rs b/compiler/rustc_codegen_ssa/src/mir/statement.rs
@@ -87,8 +87,9 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let src = src_val.immediate();
                 bx.memcpy(dst, align, src, align, bytes, crate::MemFlags::empty());
             }
+
+            mir::StatementKind::Retag { .. } => if self.cx.sess().emit_retags() {},
             mir::StatementKind::FakeRead(..)
-            | mir::StatementKind::Retag { .. }
             | mir::StatementKind::AscribeUserType(..)
             | mir::StatementKind::ConstEvalCounter
             | mir::StatementKind::PlaceMention(..)
diff --git a/compiler/rustc_codegen_ssa/src/traits/bsan.rs b/compiler/rustc_codegen_ssa/src/traits/bsan.rs
@@ -0,0 +1,9 @@
+/*
+use crate::traits::BackendTypes;
+
+pub trait BSANMethods<'tcx>: BackendTypes {
+    /// Take an inline assembly expression and splat it out via LLVM
+    fn track_operand(&mut self);
+}
+
+ */
diff --git a/compiler/rustc_codegen_ssa/src/traits/mod.rs b/compiler/rustc_codegen_ssa/src/traits/mod.rs
@@ -14,6 +14,7 @@
 mod abi;
 mod asm;
 mod backend;
+mod bsan;
 mod builder;
 mod consts;
 mod coverageinfo;
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -31,6 +31,7 @@
 #include "llvm/Transforms/IPO/LowerTypeTests.h"
 #include "llvm/Transforms/IPO/ThinLTOBitcodeWriter.h"
 #include "llvm/Transforms/Instrumentation/AddressSanitizer.h"
+#include "llvm/Transforms/Instrumentation/BorrowSanitizer.h"
 #include "llvm/Transforms/Instrumentation/DataFlowSanitizer.h"
 #include "llvm/Transforms/Instrumentation/HWAddressSanitizer.h"
 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
@@ -670,6 +671,7 @@ struct LLVMRustSanitizerOptions {
   bool SanitizeHWAddressRecover;
   bool SanitizeKernelAddress;
   bool SanitizeKernelAddressRecover;
+  bool SanitizeBorrow;
 };
 
 extern "C" LLVMRustResult LLVMRustOptimize(
@@ -920,6 +922,13 @@ extern "C" LLVMRustResult LLVMRustOptimize(
             MPM.addPass(HWAddressSanitizerPass(opts));
           });
     }
+    if (SanitizerOptions->SanitizeBorrow) {
+      OptimizerLastEPCallbacks.push_back(
+          [SanitizerOptions](ModulePassManager &MPM, OptimizationLevel Level) {
+            BorrowSanitizerOptions opts;
+            MPM.addPass(BorrowSanitizerPass(opts));
+          });
+    }
   }
 
   ModulePassManager MPM;
diff --git a/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/RustWrapper.cpp
@@ -358,6 +358,8 @@ static Attribute::AttrKind fromRust(LLVMRustAttributeKind Kind) {
     return Attribute::Writable;
   case LLVMRustAttributeKind::DeadOnUnwind:
     return Attribute::DeadOnUnwind;
+  case SanitizeBorrow:
+    return Attribute::SanitizeBorrow;
   }
   report_fatal_error("bad LLVMRustAttributeKind");
 }
diff --git a/compiler/rustc_mir_transform/src/add_retag.rs b/compiler/rustc_mir_transform/src/add_retag.rs
@@ -7,7 +7,6 @@
 use rustc_hir::LangItem;
 use rustc_middle::mir::*;
 use rustc_middle::ty::{self, Ty, TyCtxt};
-
 pub(super) struct AddRetag;
 
 /// Determine whether this type may contain a reference (or box), and thus needs retagging.
@@ -50,7 +49,7 @@ fn may_contain_reference<'tcx>(ty: Ty<'tcx>, depth: u32, tcx: TyCtxt<'tcx>) -> b
 
 impl<'tcx> crate::MirPass<'tcx> for AddRetag {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        sess.opts.unstable_opts.mir_emit_retag
+        sess.emit_retags()
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {
diff --git a/compiler/rustc_mir_transform/src/shim.rs b/compiler/rustc_mir_transform/src/shim.rs
@@ -245,7 +245,7 @@ fn build_drop_shim<'tcx>(tcx: TyCtxt<'tcx>, def_id: DefId, ty: Option<Ty<'tcx>>)
 
     // The first argument (index 0), but add 1 for the return value.
     let mut dropee_ptr = Place::from(Local::new(1 + 0));
-    if tcx.sess.opts.unstable_opts.mir_emit_retag {
+    if tcx.sess.emit_retags() {
         // We want to treat the function argument as if it was passed by `&mut`. As such, we
         // generate
         // ```
diff --git a/compiler/rustc_session/src/options.rs b/compiler/rustc_session/src/options.rs
@@ -384,7 +384,7 @@ mod desc {
     pub(crate) const parse_opt_panic_strategy: &str = parse_panic_strategy;
     pub(crate) const parse_oom_strategy: &str = "either `panic` or `abort`";
     pub(crate) const parse_relro_level: &str = "one of: `full`, `partial`, or `off`";
-    pub(crate) const parse_sanitizers: &str = "comma separated list of sanitizers: `address`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `leak`, `memory`, `memtag`, `safestack`, `shadow-call-stack`, or `thread`";
+    pub(crate) const parse_sanitizers: &str = "comma separated list of sanitizers: `address`, `borrow`, `cfi`, `dataflow`, `hwaddress`, `kcfi`, `kernel-address`, `leak`, `memory`, `memtag`, `safestack`, `shadow-call-stack`, or `thread`";
     pub(crate) const parse_sanitizer_memory_track_origins: &str = "0, 1, or 2";
     pub(crate) const parse_cfguard: &str =
         "either a boolean (`yes`, `no`, `on`, `off`, etc), `checks`, or `nochecks`";
@@ -823,6 +823,7 @@ pub mod parse {
                     "thread" => SanitizerSet::THREAD,
                     "hwaddress" => SanitizerSet::HWADDRESS,
                     "safestack" => SanitizerSet::SAFESTACK,
+                    "borrow" => SanitizerSet::BORROW,
                     _ => return false,
                 }
             }
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
@@ -2,9 +2,9 @@ use std::any::Any;
 use std::ops::{Div, Mul};
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
-use std::sync::Arc;
 use std::sync::atomic::AtomicBool;
 use std::sync::atomic::Ordering::SeqCst;
+use std::sync::Arc;
 use std::{env, fmt, io};
 
 use rustc_data_structures::flock;
@@ -22,8 +22,8 @@ use rustc_errors::emitter::{
 use rustc_errors::json::JsonEmitter;
 use rustc_errors::registry::Registry;
 use rustc_errors::{
-    Diag, DiagCtxt, DiagCtxtHandle, DiagMessage, Diagnostic, ErrorGuaranteed, FatalAbort,
-    FluentBundle, LazyFallbackBundle, TerminalUrl, fallback_fluent_bundle,
+    fallback_fluent_bundle, Diag, DiagCtxt, DiagCtxtHandle, DiagMessage, Diagnostic,
+    ErrorGuaranteed, FatalAbort, FluentBundle, LazyFallbackBundle, TerminalUrl,
 };
 use rustc_macros::HashStable_Generic;
 pub use rustc_span::def_id::StableCrateId;
@@ -613,7 +613,13 @@ impl Session {
         // AddressSanitizer and KernelAddressSanitizer uses lifetimes to detect use after scope bugs.
         // MemorySanitizer uses lifetimes to detect use of uninitialized stack variables.
         // HWAddressSanitizer will use lifetimes to detect use after scope bugs in the future.
-        || self.opts.unstable_opts.sanitizer.intersects(SanitizerSet::ADDRESS | SanitizerSet::KERNELADDRESS | SanitizerSet::MEMORY | SanitizerSet::HWADDRESS)
+        // BorrowSanitizer will eventually use lifetimes as well.
+        || self.opts.unstable_opts.sanitizer.intersects(SanitizerSet::ADDRESS | SanitizerSet::BORROW | SanitizerSet::KERNELADDRESS | SanitizerSet::MEMORY | SanitizerSet::HWADDRESS)
+    }
+
+    pub fn emit_retags(&self) -> bool {
+        self.opts.unstable_opts.mir_emit_retag
+            || self.opts.unstable_opts.sanitizer.intersects(SanitizerSet::BORROW)
     }
 
     pub fn diagnostic_width(&self) -> usize {
@@ -657,10 +663,13 @@ impl Session {
     }
 
     pub fn mir_opt_level(&self) -> usize {
-        self.opts
-            .unstable_opts
-            .mir_opt_level
-            .unwrap_or_else(|| if self.opts.optimize != OptLevel::No { 2 } else { 1 })
+        self.opts.unstable_opts.mir_opt_level.unwrap_or_else(|| {
+            if self.opts.optimize != OptLevel::No {
+                2
+            } else {
+                1
+            }
+        })
     }
 
     /// Calculates the flavor of LTO to use for this compilation.
@@ -741,7 +750,8 @@ impl Session {
             let more_names = self.opts.output_types.contains_key(&OutputType::LlvmAssembly)
                 || self.opts.output_types.contains_key(&OutputType::Bitcode)
                 // AddressSanitizer and MemorySanitizer use alloca name when reporting an issue.
-                || self.opts.unstable_opts.sanitizer.intersects(SanitizerSet::ADDRESS | SanitizerSet::MEMORY);
+                // BorrowSanitizer should also have this information.
+                || self.opts.unstable_opts.sanitizer.intersects(SanitizerSet::ADDRESS | SanitizerSet::BORROW | SanitizerSet::MEMORY);
             !more_names
         }
     }
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -500,6 +500,7 @@ symbols! {
         block,
         bool,
         bool_then,
+        borrow,
         borrowck_graphviz_format,
         borrowck_graphviz_postflow,
         box_new,
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
@@ -1394,6 +1394,7 @@ bitflags::bitflags! {
         const KERNELADDRESS = 1 << 9;
         const SAFESTACK = 1 << 10;
         const DATAFLOW = 1 << 11;
+        const BORROW = 1 << 12;
     }
 }
 rustc_data_structures::external_bitflags_debug! { SanitizerSet }
@@ -1408,6 +1409,13 @@ impl SanitizerSet {
         (SanitizerSet::ADDRESS, SanitizerSet::MEMTAG),
         (SanitizerSet::ADDRESS, SanitizerSet::KERNELADDRESS),
         (SanitizerSet::ADDRESS, SanitizerSet::SAFESTACK),
+        (SanitizerSet::BORROW, SanitizerSet::ADDRESS),
+        (SanitizerSet::BORROW, SanitizerSet::MEMORY),
+        (SanitizerSet::BORROW, SanitizerSet::THREAD),
+        (SanitizerSet::BORROW, SanitizerSet::HWADDRESS),
+        (SanitizerSet::BORROW, SanitizerSet::MEMTAG),
+        (SanitizerSet::BORROW, SanitizerSet::KERNELADDRESS),
+        (SanitizerSet::BORROW, SanitizerSet::SAFESTACK),
         (SanitizerSet::LEAK, SanitizerSet::MEMORY),
         (SanitizerSet::LEAK, SanitizerSet::THREAD),
         (SanitizerSet::LEAK, SanitizerSet::KERNELADDRESS),
@@ -1444,6 +1452,7 @@ impl SanitizerSet {
             SanitizerSet::SHADOWCALLSTACK => "shadow-call-stack",
             SanitizerSet::THREAD => "thread",
             SanitizerSet::HWADDRESS => "hwaddress",
+            SanitizerSet::BORROW => "borrow",
             _ => return None,
         })
     }
@@ -3170,6 +3179,7 @@ impl Target {
                                 Some("shadow-call-stack") => SanitizerSet::SHADOWCALLSTACK,
                                 Some("thread") => SanitizerSet::THREAD,
                                 Some("hwaddress") => SanitizerSet::HWADDRESS,
+                                Some("borrow") => SanitizerSet::BORROW,
                                 Some(s) => return Err(format!("unknown sanitizer {}", s)),
                                 _ => return Err(format!("not a string: {:?}", s)),
                             };
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/aarch64_apple_darwin.rs
@@ -21,7 +21,7 @@ pub(crate) fn target() -> Target {
             cpu: "apple-m1".into(),
             max_atomic_width: Some(128),
             // FIXME: The leak sanitizer currently fails the tests, see #88132.
-            supported_sanitizers: SanitizerSet::ADDRESS | SanitizerSet::CFI | SanitizerSet::THREAD,
+            supported_sanitizers: SanitizerSet::ADDRESS | SanitizerSet::BORROW | SanitizerSet::CFI | SanitizerSet::THREAD,
             ..opts
         },
     }
diff --git a/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/aarch64_unknown_linux_gnu.rs
@@ -18,6 +18,7 @@ pub(crate) fn target() -> Target {
             max_atomic_width: Some(128),
             stack_probes: StackProbeType::Inline,
             supported_sanitizers: SanitizerSet::ADDRESS
+                | SanitizerSet::BORROW
                 | SanitizerSet::CFI
                 | SanitizerSet::KCFI
                 | SanitizerSet::LEAK
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64_apple_darwin.rs
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_msvc.rs b/compiler/rustc_target/src/spec/targets/x86_64_pc_windows_msvc.rs
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_fuchsia.rs
diff --git a/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs b/compiler/rustc_target/src/spec/targets/x86_64_unknown_linux_gnu.rs
diff --git a/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs b/compiler/rustc_target/src/spec/targets/x86_64h_apple_darwin.rs
diff --git a/src/bootstrap/src/core/build_steps/llvm.rs b/src/bootstrap/src/core/build_steps/llvm.rs
diff --git a/src/ci/scripts/sync.sh b/src/ci/scripts/sync.sh
diff --git a/src/tools/bsan/Cargo.toml b/src/tools/bsan/Cargo.toml
diff --git a/src/tools/bsan/src/lib.rs b/src/tools/bsan/src/lib.rs
diff --git a/src/tools/bsan/src/main.rs b/src/tools/bsan/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -114,6 +114,9 @@ pub(crate) fn sanitize_attrs<'ll>(`
`114`	`114`	`if enabled.contains(SanitizerSet::SAFESTACK) {`
`115`	`115`	`attrs.push(llvm::AttributeKind::SanitizeSafeStack.create_attr(cx.llcx));`
`116`	`116`	`}`
	`117`	`+ if enabled.contains(SanitizerSet::BORROW) {`
	`118`	`+ attrs.push(llvm::AttributeKind::SanitizeBorrow.create_attr(cx.llcx));`
	`119`	`+ }`
`117`	`120`	`attrs`
`118`	`121`	`}`
`119`	`122`
Original file line number	Diff line number	Diff line change
`@@ -252,6 +252,7 @@ pub enum AttributeKind {`
`252`	`252`	`FnRetThunkExtern = 41,`
`253`	`253`	`Writable = 42,`
`254`	`254`	`DeadOnUnwind = 43,`
	`255`	`+ SanitizeBorrow = 44,`
`255`	`256`	`}`
`256`	`257`
`257`	`258`	`/// LLVMIntPredicate`
`@@ -541,6 +542,7 @@ pub struct SanitizerOptions {`
`541`	`542`	`pub sanitize_hwaddress_recover: bool,`
`542`	`543`	`pub sanitize_kernel_address: bool,`
`543`	`544`	`pub sanitize_kernel_address_recover: bool,`
	`545`	`+ pub sanitize_borrow: bool,`
`544`	`546`	`}`
`545`	`547`
`546`	`548`	`/// LLVMRelocMode`