add const_allocate intrinsic

compiler/rustc_mir/src/const_eval/machine.rs

@@ -1,5 +1,6 @@
 use rustc_middle::mir;
 use rustc_middle::ty::layout::HasTyCtxt;
+use rustc_middle::ty::InstanceDef;
 use rustc_middle::ty::{self, Ty};
 use std::borrow::Borrow;
 use std::collections::hash_map::Entry;
@@ -231,8 +232,13 @@ impl<'mir, 'tcx> interpret::Machine<'mir, 'tcx> for CompileTimeInterpreter<'mir,
             if ecx.tcx.is_const_fn_raw(def.did) {
                 // If this function is a `const fn` then under certain circumstances we
                 // can evaluate call via the query system, thus memoizing all future calls.
-                if ecx.try_eval_const_fn_call(instance, ret, args)? {
-                    return Ok(None);
+                match instance.def {
+                    InstanceDef::Intrinsic(_) => {
+                        if ecx.try_eval_const_fn_call(instance, ret, args)? {
+                            return Ok(None);
+                        }
+                    }
+                    _ => {}
                 }
             } else {
                 // Some functions we support even if they are non-const -- but avoid testing

compiler/rustc_mir/src/interpret/intrinsics.rs

@@ -344,7 +344,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> {
 
                 let align = match Align::from_bytes(align) {
                     Ok(a) => a,
-                    Err(err) => bug!("align has to power of 2, {}", err),
+                    Err(err) => throw_ub_format!("align has to be a power of 2, {}", err),
                 };
 
                 let ptr =

compiler/rustc_mir/src/interpret/memory.rs

@@ -42,7 +42,7 @@ impl<T: MayLeak> MayLeak for MemoryKind<T> {
     fn may_leak(self) -> bool {
         match self {
             MemoryKind::Stack => false,
-            MemoryKind::Heap => true,
+            MemoryKind::Heap => false,
             MemoryKind::Vtable => true,
             MemoryKind::CallerLocation => true,
             MemoryKind::Machine(k) => k.may_leak(),
@@ -54,7 +54,7 @@ impl<T: fmt::Display> fmt::Display for MemoryKind<T> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             MemoryKind::Stack => write!(f, "stack variable"),
-            MemoryKind::Heap => write!(f, "heap variable"),
+            MemoryKind::Heap => write!(f, "heap allocation"),
             MemoryKind::Vtable => write!(f, "vtable"),
             MemoryKind::CallerLocation => write!(f, "caller location"),
             MemoryKind::Machine(m) => write!(f, "{}", m),

library/core/src/intrinsics.rs

@@ -1734,7 +1734,7 @@ extern "rust-intrinsic" {
     pub fn ptr_guaranteed_ne<T>(ptr: *const T, other: *const T) -> bool;
 
     /// Allocate at compile time. Should not be called at runtime.
-    #[rustc_const_unstable(feature = "const_heap", issue = "none")]
+    #[rustc_const_unstable(feature = "const_heap", issue = "79597")]
     #[cfg(not(bootstrap))]
     pub fn const_allocate(size: usize, align: usize) -> *mut u8;
 }

src/test/ui/consts/const-eval/heap/alloc_intrinsic_errors.rs

@@ -0,0 +1,17 @@
+#![feature(core_intrinsics)]
+#![feature(const_heap)]
+#![feature(const_raw_ptr_deref)]
+#![feature(const_mut_refs)]
+use std::intrinsics;
+
+const FOO: i32 = foo();
+const fn foo() -> i32 {
+    unsafe {
+        let _ = intrinsics::const_allocate(4, 3) as * mut i32;
+        //~^ error: any use of this value will cause an error [const_err]
+    }
+    1
+
+}
+
+fn main() {}

src/test/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr

@@ -0,0 +1,17 @@
+error: any use of this value will cause an error
+  --> $DIR/alloc_intrinsic_errors.rs:10:17
+   |
+LL | const FOO: i32 = foo();
+   | -----------------------
+...
+LL |         let _ = intrinsics::const_allocate(4, 3) as * mut i32;
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                 |
+   |                 align has to be a power of 2, `3` is not a power of 2
+   |                 inside `foo` at $DIR/alloc_intrinsic_errors.rs:10:17
+   |                 inside `FOO` at $DIR/alloc_intrinsic_errors.rs:7:18
+   |
+   = note: `#[deny(const_err)]` on by default
+
+error: aborting due to previous error
+

src/test/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.rs

@@ -1,11 +1,11 @@
-// run-pass
 #![feature(core_intrinsics)]
 #![feature(const_heap)]
 #![feature(const_raw_ptr_deref)]
 #![feature(const_mut_refs)]
 use std::intrinsics;
 
 const FOO: *const i32 = foo();
+//~^ error: untyped pointers are not allowed in constant
 
 const fn foo() -> &'static i32 {
     let t = unsafe {

src/test/ui/consts/const-eval/heap/alloc_intrinsic_nontransient.stderr

@@ -0,0 +1,8 @@
+error: untyped pointers are not allowed in constant
+  --> $DIR/alloc_intrinsic_nontransient.rs:7:1
+   |
+LL | const FOO: *const i32 = foo();
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to previous error
+