Define llvm.is.constant for primitives

Author: Centri3

compiler/rustc_codegen_llvm/src/context.rs

@@ -908,10 +908,19 @@ impl<'ll> CodegenCx<'ll, '_> {
         ifn!("llvm.lifetime.start.p0i8", fn(t_i64, ptr) -> void);
         ifn!("llvm.lifetime.end.p0i8", fn(t_i64, ptr) -> void);
 
-        // Defining only the `ptr` variant of this overloaded intrinsic means
-        // we can call this on any type we want (that doesn't ICE), but at the
-        // slight cost of needing to write `addr_of!` everywhere.
-        ifn!("llvm.is.constant.ptr", fn(ptr) -> i1);
+        // FIXME: This is an infinitesimally small portion of the types you can
+        // pass to this intrinsic, if we can ever lazily register intrinsics we
+        // should register these when they're used, that way any type can be
+        // passed.
+        ifn!("llvm.is.constant.i1", fn(i1) -> i1);
+        ifn!("llvm.is.constant.i8", fn(t_i8) -> i1);
+        ifn!("llvm.is.constant.i16", fn(t_i16) -> i1);
+        ifn!("llvm.is.constant.i32", fn(t_i32) -> i1);
+        ifn!("llvm.is.constant.i64", fn(t_i64) -> i1);
+        ifn!("llvm.is.constant.i128", fn(t_i128) -> i1);
+        ifn!("llvm.is.constant.isize", fn(t_isize) -> i1);
+        ifn!("llvm.is.constant.f32", fn(t_f32) -> i1);
+        ifn!("llvm.is.constant.f64", fn(t_f64) -> i1);
 
         ifn!("llvm.expect.i1", fn(i1, i1) -> i1);
         ifn!("llvm.eh.typeid.for", fn(ptr) -> t_i32);

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -119,9 +119,10 @@ impl<'ll, 'tcx> IntrinsicCallMethods<'tcx> for Builder<'_, 'll, 'tcx> {
             sym::likely => {
                 self.call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(true)])
             }
-            sym::is_val_statically_known => {
-                self.call_intrinsic("llvm.is.constant.ptr", &[args[0].immediate()])
-            }
+            sym::is_val_statically_known => self.call_intrinsic(
+                &format!("llvm.is.constant.{:?}", args[0].layout.llvm_type(self.cx)),
+                &[args[0].immediate()],
+            ),
             sym::unlikely => self
                 .call_intrinsic("llvm.expect.i1", &[args[0].immediate(), self.const_bool(false)]),
             kw::Try => {

compiler/rustc_hir_analysis/src/check/intrinsic.rs

@@ -453,9 +453,7 @@ pub fn check_intrinsic_type(tcx: TyCtxt<'_>, it: &hir::ForeignItem<'_>) {
 
             sym::black_box => (1, vec![param(0)], param(0)),
 
-            sym::is_val_statically_known => {
-                (1, vec![Ty::new_imm_ptr(tcx, param(0))], tcx.types.bool)
-            }
+            sym::is_val_statically_known => (1, vec![param(0)], tcx.types.bool),
 
             sym::const_eval_select => (4, vec![param(0), param(1), param(2)], param(3)),
 

library/core/src/intrinsics.rs

@@ -2546,14 +2546,14 @@ extern "rust-intrinsic" {
     #[rustc_const_unstable(feature = "is_val_statically_known", issue = "none")]
     #[rustc_nounwind]
     #[cfg(not(bootstrap))]
-    pub fn is_val_statically_known<T>(arg: *const T) -> bool;
+    pub fn is_val_statically_known<T>(arg: T) -> bool;
 }
 
 // FIXME: Seems using `unstable` here completely ignores `rustc_allow_const_fn_unstable`
 // and thus compiling stage0 core doesn't work.
 #[rustc_const_stable(feature = "is_val_statically_known", since = "never")]
 #[cfg(bootstrap)]
-pub const unsafe fn is_val_statically_known<T>(_: *const T) -> bool {
+pub const unsafe fn is_val_statically_known<T: ~const crate::marker::Destruct>(_: T) -> bool {
     false
 }
 

library/core/src/num/int_macros.rs

@@ -2091,7 +2091,7 @@ macro_rules! int_impl {
         #[rustc_allow_const_fn_unstable(is_val_statically_known)]
         pub const fn pow(self, mut exp: u32) -> Self {
             // SAFETY: This path has the same behavior as the other.
-            if unsafe { intrinsics::is_val_statically_known(ptr::addr_of!(self)) }
+            if unsafe { intrinsics::is_val_statically_known(self) }
                 && self > 0
                 && (self & (self - 1) == 0)
             {

library/core/src/num/mod.rs

@@ -6,7 +6,6 @@ use crate::ascii;
 use crate::intrinsics;
 use crate::mem;
 use crate::ops::{Add, Mul, Sub};
-use crate::ptr;
 use crate::str::FromStr;
 
 // Used because the `?` operator is not allowed in a const context.

library/core/src/num/uint_macros.rs

@@ -1987,7 +1987,7 @@ macro_rules! uint_impl {
             // instruction, but we must add a couple more checks for parity with
             // our own `pow`.
             // SAFETY: This path has the same behavior as the other.
-            if unsafe { intrinsics::is_val_statically_known(ptr::addr_of!(self)) }
+            if unsafe { intrinsics::is_val_statically_known(self) }
                 && self.is_power_of_two()
             {
                 let power_used = match self.checked_ilog2() {

tests/codegen/is_compile_time_known.rs renamed to tests/codegen/is_val_statically_known.rs

@@ -1,7 +1,7 @@
 // compile-flags: --crate-type=lib
 #![feature(core_intrinsics)]
 
-use std::intrinsics::is_compile_time_known;
+use std::intrinsics::is_val_statically_known;
 
 pub struct A(u32);
 pub enum B {
@@ -10,7 +10,7 @@ pub enum B {
 
 #[inline]
 pub fn tuple_struct(a: A) -> i32 {
-    if unsafe { is_compile_time_known(a) } { 1 } else { 0 }
+    if unsafe { is_val_statically_known(a) } { 1 } else { 0 }
 }
 
 // CHECK-LABEL: @tuple_struct_true(
@@ -29,7 +29,7 @@ pub fn tuple_struct_false(a: A) -> i32 {
 
 #[inline]
 pub fn r#enum(b: B) -> i32 {
-    if unsafe { is_compile_time_known(b) } { 3 } else { 2 }
+    if unsafe { is_val_statically_known(b) } { 3 } else { 2 }
 }
 
 // CHECK-LABEL: @enum_true(