add an Rvalue for is_val_statically_known and use it in MIR optimization

Author: joboet

compiler/rustc_borrowck/src/lib.rs

@@ -1535,7 +1535,8 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
             | Rvalue::Repeat(operand, _)
             | Rvalue::UnaryOp(_ /*un_op*/, operand)
             | Rvalue::Cast(_ /*cast_kind*/, operand, _ /*ty*/)
-            | Rvalue::ShallowInitBox(operand, _ /*ty*/) => {
+            | Rvalue::ShallowInitBox(operand, _ /*ty*/)
+            | Rvalue::StaticallyKnown(operand) => {
                 self.consume_operand(location, (operand, span), state)
             }
 

compiler/rustc_borrowck/src/polonius/legacy/loan_invalidations.rs

@@ -299,7 +299,8 @@ impl<'a, 'tcx> LoanInvalidationsGenerator<'a, 'tcx> {
             | Rvalue::Repeat(operand, _)
             | Rvalue::UnaryOp(_ /*un_op*/, operand)
             | Rvalue::Cast(_ /*cast_kind*/, operand, _ /*ty*/)
-            | Rvalue::ShallowInitBox(operand, _ /*ty*/) => self.consume_operand(location, operand),
+            | Rvalue::ShallowInitBox(operand, _ /*ty*/)
+            | Rvalue::StaticallyKnown(operand) => self.consume_operand(location, operand),
 
             &Rvalue::CopyForDeref(place) => {
                 let op = &Operand::Copy(place);

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -1633,7 +1633,8 @@ impl<'a, 'tcx> Visitor<'tcx> for TypeChecker<'a, 'tcx> {
             | Rvalue::ThreadLocalRef(..)
             | Rvalue::Len(..)
             | Rvalue::Discriminant(..)
-            | Rvalue::NullaryOp(NullOp::OffsetOf(..), _) => {}
+            | Rvalue::NullaryOp(NullOp::OffsetOf(..), _)
+            | Rvalue::StaticallyKnown(_) => {}
         }
     }
 
@@ -2209,7 +2210,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
             | Rvalue::CopyForDeref(..)
             | Rvalue::UnaryOp(..)
             | Rvalue::Discriminant(..)
-            | Rvalue::WrapUnsafeBinder(..) => None,
+            | Rvalue::WrapUnsafeBinder(..)
+            | Rvalue::StaticallyKnown(..) => None,
 
             Rvalue::Aggregate(aggregate, _) => match **aggregate {
                 AggregateKind::Adt(_, _, _, user_ty, _) => user_ty,

compiler/rustc_codegen_gcc/src/builder.rs

@@ -925,6 +925,12 @@ impl<'a, 'gcc, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'gcc, 'tcx> {
         self.gcc_checked_binop(oop, typ, lhs, rhs)
     }
 
+    fn is_constant(&mut self, val: Self::Value) -> Self::Value {
+        let builtin = self.context.get_builtin_function("__builtin_constant_p");
+        let res = self.context.new_call(None, builtin, &[val]);
+        self.icmp(IntPredicate::IntEQ, res, self.const_i32(0))
+    }
+
     fn alloca(&mut self, size: Size, align: Align) -> RValue<'gcc> {
         let ty = self.cx.type_array(self.cx.type_i8(), size.bytes()).get_aligned(align.bytes());
         // TODO(antoyo): It might be better to return a LValue, but fixing the rustc API is non-trivial.

compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

@@ -381,12 +381,6 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                     &args.iter().map(|arg| arg.immediate()).collect::<Vec<_>>(),
                 )
             }
-            sym::is_val_statically_known => {
-                let a = args[0].immediate();
-                let builtin = self.context.get_builtin_function("__builtin_constant_p");
-                let res = self.context.new_call(None, builtin, &[a]);
-                self.icmp(IntPredicate::IntEQ, res, self.const_i32(0))
-            }
             sym::catch_unwind => {
                 try_intrinsic(
                     self,

compiler/rustc_codegen_llvm/src/builder.rs

@@ -1103,6 +1103,10 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
         Some(self.call_intrinsic(name, &[self.type_i8(), self.type_ix(size.bits())], &[lhs, rhs]))
     }
 
+    fn is_constant(&mut self, val: Self::Value) -> Self::Value {
+        self.call_intrinsic("llvm.is.constant", &[self.cx.val_ty(val)], &[val])
+    }
+
     /* Miscellaneous instructions */
     fn memcpy(
         &mut self,

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -198,17 +198,6 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 codegen_autodiff(self, tcx, instance, args, result);
                 return Ok(());
             }
-            sym::is_val_statically_known => {
-                if let OperandValue::Immediate(imm) = args[0].val {
-                    self.call_intrinsic(
-                        "llvm.is.constant",
-                        &[args[0].layout.immediate_llvm_type(self.cx)],
-                        &[imm],
-                    )
-                } else {
-                    self.const_bool(false)
-                }
-            }
             sym::select_unpredictable => {
                 let cond = args[0].immediate();
                 assert_eq!(args[1].layout, args[2].layout);

compiler/rustc_codegen_ssa/src/mir/rvalue.rs

@@ -737,6 +737,27 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                 let layout = bx.cx().layout_of(binder_ty);
                 OperandRef { val: operand.val, layout }
             }
+            mir::Rvalue::StaticallyKnown(ref operand) => {
+                let operand = self.codegen_operand(bx, operand);
+                let val = match operand.val {
+                    // This would need to insert some loads for the type. That's
+                    // unlikely to be profitable, so just collapse to `false`.
+                    OperandValue::Ref(..) => bx.const_bool(false),
+                    OperandValue::Immediate(val) => bx.is_constant(val),
+                    OperandValue::Pair(lval, rval) => {
+                        let l = bx.is_constant(lval);
+                        let r = bx.is_constant(rval);
+                        bx.and(l, r)
+                    }
+                    // A zero-sized value is always constant, so the backend
+                    // knows everything there is to know about it.
+                    OperandValue::ZeroSized => bx.const_bool(true),
+                };
+                OperandRef {
+                    val: OperandValue::Immediate(val),
+                    layout: bx.cx().layout_of(bx.tcx().types.bool),
+                }
+            }
         }
     }
 

compiler/rustc_codegen_ssa/src/traits/builder.rs

@@ -293,6 +293,15 @@ pub trait BuilderMethods<'a, 'tcx>:
         self.assume(is_null);
     }
 
+    /// Returns whether `val` has a value known at compile-time.
+    ///
+    /// Defaults to always returning `false`, since returning `true` might trick
+    /// the program into performing costly checks that only make sense at
+    /// compile-time.
+    fn is_constant(&mut self, _val: Self::Value) -> Self::Value {
+        self.const_bool(false)
+    }
+
     fn range_metadata(&mut self, load: Self::Value, range: WrappingRange);
     fn nonnull_metadata(&mut self, load: Self::Value);
 

compiler/rustc_const_eval/src/check_consts/check.rs

@@ -708,6 +708,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'_, 'tcx> {
             Rvalue::WrapUnsafeBinder(..) => {
                 // Unsafe binders are always trivial to create.
             }
+
+            Rvalue::StaticallyKnown(..) => {
+                // We can always choose a value for this.
+            }
         }
     }