[WIP] Implement unchecked_disjoint_bitor

compiler/rustc_codegen_cranelift/src/codegen_i128.rs

@@ -21,7 +21,7 @@ pub(crate) fn maybe_codegen<'tcx>(
  let is_signed = type_sign(lhs.layout().ty);
 
  match bin_op {
- BinOp::BitAnd | BinOp::BitOr | BinOp::BitXor => None,
+ BinOp::BitAnd | BinOp::BitOr | BinOp::BitXor | BinOp::BitOrDisjoint => None,
  BinOp::Add | BinOp::AddUnchecked | BinOp::Sub | BinOp::SubUnchecked => None,
  BinOp::Mul | BinOp::MulUnchecked => {
  let args = [lhs.load_scalar(fx), rhs.load_scalar(fx)];
@@ -90,7 +90,7 @@ pub(crate) fn maybe_codegen_checked<'tcx>(
  let is_signed = type_sign(lhs.layout().ty);
 
  match bin_op {
- BinOp::BitAnd | BinOp::BitOr | BinOp::BitXor => unreachable!(),
+ BinOp::BitAnd | BinOp::BitOr | BinOp::BitXor | BinOp::BitOrDisjoint => unreachable!(),
  BinOp::Mul if is_signed => {
  let out_ty = Ty::new_tup(fx.tcx, &[lhs.layout().ty, fx.tcx.types.bool]);
  let oflow = CPlace::new_stack_slot(fx, fx.layout_of(fx.tcx.types.i32));

compiler/rustc_codegen_cranelift/src/num.rs

@@ -149,6 +149,7 @@ pub(crate) fn codegen_int_binop<'tcx>(
 
  let b = fx.bcx.ins();
  // FIXME trap on overflow for the Unchecked versions
+ // FIXME trap on non-disjoint for BitOrDisjoint
  let val = match bin_op {
  BinOp::Add | BinOp::AddUnchecked => b.iadd(lhs, rhs),
  BinOp::Sub | BinOp::SubUnchecked => b.isub(lhs, rhs),
@@ -169,7 +170,7 @@ pub(crate) fn codegen_int_binop<'tcx>(
  }
  BinOp::BitXor => b.bxor(lhs, rhs),
  BinOp::BitAnd => b.band(lhs, rhs),
- BinOp::BitOr => b.bor(lhs, rhs),
+ BinOp::BitOr | BinOp::BitOrDisjoint => b.bor(lhs, rhs),
  BinOp::Shl | BinOp::ShlUnchecked => b.ishl(lhs, rhs),
  BinOp::Shr | BinOp::ShrUnchecked => {
  if signed {

compiler/rustc_codegen_gcc/src/builder.rs

@@ -25,7 +25,7 @@ use rustc_middle::ty::layout::{
  FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasParamEnv, HasTyCtxt, LayoutError, LayoutOfHelpers,
  TyAndLayout,
 };
-use rustc_middle::ty::{ParamEnv, Ty, TyCtxt, Instance};
+use rustc_middle::ty::{Instance, ParamEnv, Ty, TyCtxt};
 use rustc_span::def_id::DefId;
 use rustc_span::Span;
 use rustc_target::abi::{
@@ -792,6 +792,11 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
  self.cx.gcc_or(a, b, self.location)
  }
 
+ fn disjoint_or(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
+ // TODO: investigate gcc equivalent of this operation
+ self.cx.gcc_or(a, b, self.location)
+ }
+
  fn xor(&mut self, a: RValue<'gcc>, b: RValue<'gcc>) -> RValue<'gcc> {
  set_rvalue_location(self, self.gcc_xor(a, b))
  }
@@ -903,11 +908,7 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
  // TODO(antoyo): It might be better to return a LValue, but fixing the rustc API is non-trivial.
  self.stack_var_count.set(self.stack_var_count.get() + 1);
  self.current_func()
- .new_local(
- self.location,
- ty,
- &format!("stack_var_{}", self.stack_var_count.get()),
- )
+ .new_local(self.location, ty, &format!("stack_var_{}", self.stack_var_count.get()))
  .get_address(self.location)
  }
 

compiler/rustc_codegen_llvm/src/builder.rs

@@ -303,6 +303,14 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
  unchecked_umul(x, y) => LLVMBuildNUWMul,
  }
 
+ fn disjoint_or(&mut self, a: &'ll Value, b: &'ll Value) -> &'ll Value {
+ unsafe {
+ let or = llvm::LLVMBuildOr(self.llbuilder, a, b, UNNAMED);
+ llvm::LLVMSetIsDisjoint(or, True);
+ or
+ }
+ }
+
  fn fadd_fast(&mut self, lhs: &'ll Value, rhs: &'ll Value) -> &'ll Value {
  unsafe {
  let instr = llvm::LLVMBuildFAdd(self.llbuilder, lhs, rhs, UNNAMED);

compiler/rustc_codegen_llvm/src/llvm/ffi.rs

@@ -1273,6 +1273,7 @@ extern "C" {
  pub fn LLVMBuildNeg<'a>(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
  pub fn LLVMBuildFNeg<'a>(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
  pub fn LLVMBuildNot<'a>(B: &Builder<'a>, V: &'a Value, Name: *const c_char) -> &'a Value;
+ pub fn LLVMSetIsDisjoint(Inst: &Value, IsDisjoint: Bool);
 
  // Memory
  pub fn LLVMBuildAlloca<'a>(B: &Builder<'a>, Ty: &'a Type, Name: *const c_char) -> &'a Value;

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -867,6 +867,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
  mir::BinOp::BitOr => bx.or(lhs, rhs),
  mir::BinOp::BitAnd => bx.and(lhs, rhs),
  mir::BinOp::BitXor => bx.xor(lhs, rhs),
+ mir::BinOp::BitOrDisjoint => bx.disjoint_or(lhs, rhs),
  mir::BinOp::Offset => {
  let pointee_type = input_ty
  .builtin_deref(true)

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -122,6 +122,7 @@ pub trait BuilderMethods<'a, 'tcx>:
  fn and(&mut self, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
  fn or(&mut self, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
  fn xor(&mut self, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
+ fn disjoint_or(&mut self, lhs: Self::Value, rhs: Self::Value) -> Self::Value;
  fn neg(&mut self, v: Self::Value) -> Self::Value;
  fn fneg(&mut self, v: Self::Value) -> Self::Value;
  fn not(&mut self, v: Self::Value) -> Self::Value;

compiler/rustc_const_eval/messages.ftl

@@ -249,6 +249,9 @@ const_eval_overflow =
 const_eval_overflow_shift =
  overflowing shift by {$val} in `{$name}`
 
+const_eval_overlapping_disjoint_bit_or =
+ disjoint bitor executed on overlapping operands (`lhs & rhs != 0`)
+
 const_eval_panic =
  the evaluated program panicked at '{$msg}', {$file}:{$line}:{$col}
 

compiler/rustc_const_eval/src/errors.rs

@@ -480,6 +480,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
  RemainderByZero => const_eval_remainder_by_zero,
  DivisionOverflow => const_eval_division_overflow,
  RemainderOverflow => const_eval_remainder_overflow,
+ OverlappingDisjointBitOr => const_eval_overlapping_disjoint_bit_or,
  PointerArithOverflow => const_eval_pointer_arithmetic_overflow,
  InvalidMeta(InvalidMetaKind::SliceTooBig) => const_eval_invalid_meta_slice,
  InvalidMeta(InvalidMetaKind::TooBig) => const_eval_invalid_meta,
@@ -531,6 +532,7 @@ impl<'a> ReportErrorExt for UndefinedBehaviorInfo<'a> {
  | RemainderByZero
  | DivisionOverflow
  | RemainderOverflow
+ | OverlappingDisjointBitOr
  | PointerArithOverflow
  | InvalidMeta(InvalidMetaKind::SliceTooBig)
  | InvalidMeta(InvalidMetaKind::TooBig)

compiler/rustc_const_eval/src/interpret/operator.rs

@@ -308,6 +308,13 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
  BitAnd => ImmTy::from_uint(l & r, left.layout),
  BitXor => ImmTy::from_uint(l ^ r, left.layout),
 
+ BitOrDisjoint => {
+ if l & r != 0 {
+ throw_ub!(OverlappingDisjointBitOr)
+ }
+ ImmTy::from_uint(l | r, left.layout)
+ }
+
  Add | AddUnchecked | Sub | SubUnchecked | Mul | MulUnchecked | Rem | Div => {
  assert!(!left.layout.abi.is_signed());
  let op: fn(u128, u128) -> (u128, bool) = match bin_op {

compiler/rustc_const_eval/src/transform/validate.rs

@@ -1046,7 +1046,7 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
  )
  }
  }
- BitAnd | BitOr | BitXor => {
+ BitAnd | BitOr | BitXor | BitOrDisjoint => {
  for x in [a, b] {
  check_kinds!(
  x,

compiler/rustc_const_eval/src/util/mod.rs

@@ -18,7 +18,7 @@ pub fn binop_left_homogeneous(op: mir::BinOp) -> bool {
  use rustc_middle::mir::BinOp::*;
  match op {
  Add | AddUnchecked | Sub | SubUnchecked | Mul | MulUnchecked | Div | Rem | BitXor
- | BitAnd | BitOr | Offset | Shl | ShlUnchecked | Shr | ShrUnchecked => true,
+ | BitAnd | BitOr | BitOrDisjoint | Offset | Shl | ShlUnchecked | Shr | ShrUnchecked => true,
  Eq | Ne | Lt | Le | Gt | Ge | Cmp => false,
  }
 }
@@ -30,7 +30,7 @@ pub fn binop_right_homogeneous(op: mir::BinOp) -> bool {
  use rustc_middle::mir::BinOp::*;
  match op {
  Add | AddUnchecked | Sub | SubUnchecked | Mul | MulUnchecked | Div | Rem | BitXor
- | BitAnd | BitOr | Eq | Ne | Lt | Le | Gt | Ge | Cmp => true,
+ | BitAnd | BitOr | BitOrDisjoint | Eq | Ne | Lt | Le | Gt | Ge | Cmp => true,
  Offset | Shl | ShlUnchecked | Shr | ShrUnchecked => false,
  }
 }

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -460,7 +460,7 @@ pub fn check_intrinsic_type(
  }
  sym::unchecked_shl | sym::unchecked_shr => (2, 0, vec![param(0), param(1)], param(0)),
  sym::rotate_left | sym::rotate_right => (1, 0, vec![param(0), tcx.types.u32], param(0)),
- sym::unchecked_add | sym::unchecked_sub | sym::unchecked_mul => {
+ sym::unchecked_add | sym::unchecked_sub | sym::unchecked_mul | sym::disjoint_bitor => {
  (1, 0, vec![param(0), param(0)], param(0))
  }
  sym::wrapping_add | sym::wrapping_sub | sym::wrapping_mul => {

compiler/rustc_middle/src/mir/interpret/error.rs

@@ -307,6 +307,8 @@ pub enum UndefinedBehaviorInfo<'tcx> {
  DivisionOverflow,
  /// Signed remainder overflowed (INT_MIN % -1).
  RemainderOverflow,
+ /// Disjoint bitor operation executed on overlapping bitvectors (lhs & rhs != 0).
+ OverlappingDisjointBitOr,
  /// Overflowing inbounds pointer arithmetic.
  PointerArithOverflow,
  /// Invalid metadata in a wide pointer

compiler/rustc_middle/src/mir/syntax.rs

@@ -1478,6 +1478,9 @@ pub enum BinOp {
  BitAnd,
  /// The `|` operator (bitwise or)
  BitOr,
+ /// Equivalent to all of `BitOr`, `BitXor`, and `Add`. UB if any bit is set
+ /// in both operands; that is, if `lhs & rhs != 0`.
+ BitOrDisjoint,
  /// The `<<` operator (shift left)
  ///
  /// The offset is truncated to the size of the first operand and made unsigned before shifting.

compiler/rustc_middle/src/mir/tcx.rs

@@ -262,7 +262,8 @@ impl<'tcx> BinOp {
  | &BinOp::Rem
  | &BinOp::BitXor
  | &BinOp::BitAnd
- | &BinOp::BitOr => {
+ | &BinOp::BitOr
+ | &BinOp::BitOrDisjoint => {
  // these should be integers or floats of the same size.
  assert_eq!(lhs_ty, rhs_ty);
  lhs_ty
@@ -322,6 +323,7 @@ impl BinOp {
  | BinOp::AddUnchecked
  | BinOp::SubUnchecked
  | BinOp::MulUnchecked
+ | BinOp::BitOrDisjoint
  | BinOp::ShlUnchecked
  | BinOp::ShrUnchecked
  | BinOp::Offset => {

compiler/rustc_mir_transform/src/lower_intrinsics.rs

@@ -97,7 +97,8 @@ impl<'tcx> MirPass<'tcx> for LowerIntrinsics {
  | sym::unchecked_div
  | sym::unchecked_rem
  | sym::unchecked_shl
- | sym::unchecked_shr => {
+ | sym::unchecked_shr
+ | sym::disjoint_bitor => {
  let target = target.unwrap();
  let lhs;
  let rhs;
@@ -118,6 +119,7 @@ impl<'tcx> MirPass<'tcx> for LowerIntrinsics {
  sym::unchecked_rem => BinOp::Rem,
  sym::unchecked_shl => BinOp::ShlUnchecked,
  sym::unchecked_shr => BinOp::ShrUnchecked,
+ sym::disjoint_bitor => BinOp::BitOrDisjoint,
  _ => bug!("unexpected intrinsic"),
  };
  block.statements.push(Statement {

compiler/rustc_mir_transform/src/promote_consts.rs

@@ -545,6 +545,7 @@ impl<'tcx> Validator<'_, 'tcx> {
  | BinOp::BitXor
  | BinOp::BitAnd
  | BinOp::BitOr
+ | BinOp::BitOrDisjoint
  | BinOp::Shl
  | BinOp::ShlUnchecked
  | BinOp::Shr

compiler/rustc_smir/src/rustc_internal/internal.rs

@@ -567,6 +567,7 @@ impl RustcInternal for BinOp {
  BinOp::BitXor => rustc_middle::mir::BinOp::BitXor,
  BinOp::BitAnd => rustc_middle::mir::BinOp::BitAnd,
  BinOp::BitOr => rustc_middle::mir::BinOp::BitOr,
+ BinOp::BitOrDisjoint => rustc_middle::mir::BinOp::BitOrDisjoint,
  BinOp::Shl => rustc_middle::mir::BinOp::Shl,
  BinOp::ShlUnchecked => rustc_middle::mir::BinOp::ShlUnchecked,
  BinOp::Shr => rustc_middle::mir::BinOp::Shr,

compiler/rustc_smir/src/rustc_smir/convert/mir.rs

@@ -494,6 +494,7 @@ impl<'tcx> Stable<'tcx> for mir::BinOp {
  BinOp::BitXor => stable_mir::mir::BinOp::BitXor,
  BinOp::BitAnd => stable_mir::mir::BinOp::BitAnd,
  BinOp::BitOr => stable_mir::mir::BinOp::BitOr,
+ BinOp::BitOrDisjoint => stable_mir::mir::BinOp::BitOrDisjoint,
  BinOp::Shl => stable_mir::mir::BinOp::Shl,
  BinOp::ShlUnchecked => stable_mir::mir::BinOp::ShlUnchecked,
  BinOp::Shr => stable_mir::mir::BinOp::Shr,

compiler/rustc_span/src/symbol.rs

@@ -707,6 +707,7 @@ symbols! {
  discriminant_kind,
  discriminant_type,
  discriminant_value,
+ disjoint_bitor,
  dispatch_from_dyn,
  div,
  div_assign,

compiler/rustc_ty_utils/src/consts.rs

@@ -81,8 +81,8 @@ fn check_binop(op: mir::BinOp) -> bool {
  use mir::BinOp::*;
  match op {
  Add | AddUnchecked | Sub | SubUnchecked | Mul | MulUnchecked | Div | Rem | BitXor
- | BitAnd | BitOr | Shl | ShlUnchecked | Shr | ShrUnchecked | Eq | Lt | Le | Ne | Ge
- | Gt | Cmp => true,
+ | BitAnd | BitOr | BitOrDisjoint | Shl | ShlUnchecked | Shr | ShrUnchecked | Eq | Lt
+ | Le | Ne | Ge | Gt | Cmp => true,
  Offset => false,
  }
 }

compiler/stable_mir/src/mir/body.rs

@@ -320,6 +320,7 @@ pub enum BinOp {
  BitXor,
  BitAnd,
  BitOr,
+ BitOrDisjoint,
  Shl,
  ShlUnchecked,
  Shr,

library/core/src/intrinsics.rs

@@ -2311,6 +2311,19 @@ extern "rust-intrinsic" {
  #[rustc_nounwind]
  pub fn unchecked_mul<T: Copy>(x: T, y: T) -> T;
 
+ /// Performs an unchecked disjoint bitor operation. Equivalent to normal
+ /// bitor and bitxor operations, triggering undefined behavior if their
+ /// results differ.
+ ///
+ /// This intrinsic does not have a stable counterpart.
+ // /// The stable counterpart of this intrinsic is `unchecked_disjoint_bitor`
+ // /// on the various integer types, such as [`u16::unchecked_disjoint_bitor`]
+ // /// and [`i64::unchecked_disjoint_bitor`].
+ #[cfg(not(bootstrap))]
+ #[rustc_const_unstable(feature = "disjoint_bitor", issue = "none")]
+ #[rustc_nounwind]
+ pub fn disjoint_bitor<T: Copy>(x: T, y: T) -> T;
+
  /// Performs rotate left.
  ///
  /// Note that, unlike most intrinsics, this is safe to call;