Implement asm_const_ptr feature

The backend now fully supports codegen of const pointers, remove the
block inside typeck behind a new feature gate. Tests are also added.

Author: nbdd0121

compiler/rustc_feature/src/unstable.rs

@@ -384,6 +384,8 @@ declare_features! (
     (unstable, arbitrary_self_types, "1.23.0", Some(44874)),
     /// Allows inherent and trait methods with arbitrary self types that are raw pointers.
     (unstable, arbitrary_self_types_pointers, "1.83.0", Some(44874)),
+    /// Allows using `const` operands with pointer in inline assembly.
+    (unstable, asm_const_ptr, "CURRENT_RUSTC_VERSION", Some(128464)),
     /// Enables experimental inline assembly support for additional architectures.
     (unstable, asm_experimental_arch, "1.58.0", Some(93335)),
     /// Enables experimental register support in inline assembly.

compiler/rustc_hir_typeck/messages.ftl

@@ -15,6 +15,10 @@ hir_typeck_arg_mismatch_indeterminate = argument type mismatch was detected, but
     .note = we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new
 
 hir_typeck_as_deref_suggestion = consider using `as_deref` here
+
+hir_typeck_asm_const_ptr_unstable =
+    using pointers in asm `const` operand is experimental
+
 hir_typeck_base_expression_double_dot = base expression required after `..`
 hir_typeck_base_expression_double_dot_add_expr = add a base expression here
 hir_typeck_base_expression_double_dot_enable_default_field_values =

compiler/rustc_hir_typeck/src/errors.rs

@@ -19,6 +19,13 @@ use rustc_span::{Ident, Span, Symbol};
 
 use crate::{FnCtxt, fluent_generated as fluent};
 
+#[derive(Diagnostic)]
+#[diag(hir_typeck_asm_const_ptr_unstable)]
+pub(crate) struct AsmConstPtrUnstable {
+    #[primary_span]
+    pub span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_typeck_base_expression_double_dot, code = E0797)]
 pub(crate) struct BaseExpressionDoubleDot {

compiler/rustc_hir_typeck/src/inline_asm.rs

@@ -14,7 +14,7 @@ use rustc_target::asm::{
 use rustc_trait_selection::infer::InferCtxtExt;
 
 use crate::FnCtxt;
-use crate::errors::RegisterTypeUnstable;
+use crate::errors::{AsmConstPtrUnstable, RegisterTypeUnstable};
 
 pub(crate) struct InlineAsmCtxt<'a, 'tcx> {
     target_features: &'tcx FxIndexSet<Symbol>,
@@ -522,15 +522,46 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
                     match ty.kind() {
                         ty::Error(_) => {}
                         _ if ty.is_integral() => {}
+                        ty::FnPtr(..) => {
+                            if !self.tcx().features().asm_const_ptr() {
+                                self.tcx()
+                                    .sess
+                                    .create_feature_err(
+                                        AsmConstPtrUnstable { span: op_sp },
+                                        sym::asm_const_ptr,
+                                    )
+                                    .emit();
+                            }
+                        }
+                        ty::RawPtr(pointee, _) | ty::Ref(_, pointee, _)
+                            if self.is_thin_ptr_ty(op_sp, *pointee) =>
+                        {
+                            if !self.tcx().features().asm_const_ptr() {
+                                self.tcx()
+                                    .sess
+                                    .create_feature_err(
+                                        AsmConstPtrUnstable { span: op_sp },
+                                        sym::asm_const_ptr,
+                                    )
+                                    .emit();
+                            }
+                        }
                         _ => {
+                            let const_possible_ty = if !self.tcx().features().asm_const_ptr() {
+                                "integer"
+                            } else {
+                                "integer or thin pointer"
+                            };
                             self.fcx
                                 .dcx()
                                 .struct_span_err(op_sp, "invalid type for `const` operand")
                                 .with_span_label(
                                     self.tcx().def_span(anon_const.def_id),
                                     format!("is {} `{}`", ty.kind().article(), ty),
                                 )
-                                .with_help("`const` operands must be of an integer type")
+                                .with_help(format!(
+                                    "`const` operands must be of an {const_possible_ty} type"
+                                ))
                                 .emit();
                         }
                     }

compiler/rustc_span/src/symbol.rs

@@ -481,6 +481,7 @@ symbols! {
         asm,
         asm_cfg,
         asm_const,
+        asm_const_ptr,
         asm_experimental_arch,
         asm_experimental_reg,
         asm_goto,

tests/assembly-llvm/asm/global_asm.rs

@@ -5,6 +5,7 @@
 //@ compile-flags: -C symbol-mangling-version=v0
 
 #![crate_type = "rlib"]
+#![feature(asm_const_ptr)]
 
 use std::arch::global_asm;
 
@@ -26,6 +27,10 @@ global_asm!("call {}", sym my_func);
 global_asm!("lea rax, [rip + {}]", sym MY_STATIC);
 // CHECK: call _RNvC[[CRATE_IDENT:[a-zA-Z0-9]{12}]]_10global_asm6foobar
 global_asm!("call {}", sym foobar);
+// CHECK: lea rax, [rip + _RNKNaC[[CRATE_IDENT]]_10global_asms4_00B3_]
+global_asm!("lea rax, [rip + {}]", const &1);
+// CHECK: lea rax, [rip + _RNKNaC[[CRATE_IDENT]]_10global_asms5_00B3_+4]
+global_asm!("lea rax, [rip + {}]", const &[1; 2][1]);
 // CHECK: _RNvC[[CRATE_IDENT]]_10global_asm6foobar:
 fn foobar() {
     loop {}

tests/assembly-llvm/asm/x86-types.rs

@@ -9,7 +9,7 @@
 //@ compile-flags: -C target-feature=+avx512bw
 //@ compile-flags: -Zmerge-functions=disabled
 
-#![feature(no_core, repr_simd, f16, f128)]
+#![feature(no_core, repr_simd, f16, f128, asm_const_ptr)]
 #![crate_type = "rlib"]
 #![no_core]
 #![allow(asm_sub_register, non_camel_case_types)]
@@ -101,6 +101,15 @@ pub unsafe fn sym_static() {
     asm!("mov al, byte ptr [{}]", sym extern_static);
 }
 
+// CHECK-LABEL: const_ptr:
+// CHECK: #APP
+// CHECK: mov al, byte ptr [{{.*}}anon{{.*}}]
+// CHECK: #NO_APP
+#[no_mangle]
+pub unsafe fn const_ptr() {
+    asm!("mov al, byte ptr [{}]", const &1u8);
+}
+
 macro_rules! check {
     ($func:ident $ty:ident $class:ident $mov:literal) => {
         #[no_mangle]

tests/ui/asm/const-refs-to-static.rs

@@ -1,19 +1,20 @@
 //@ needs-asm-support
 //@ ignore-nvptx64
 //@ ignore-spirv
+//@ build-pass
+
+#![feature(asm_const_ptr)]
 
 use std::arch::{asm, global_asm};
 use std::ptr::addr_of;
 
 static FOO: u8 = 42;
 
-global_asm!("{}", const addr_of!(FOO));
-//~^ ERROR invalid type for `const` operand
+global_asm!("/* {} */", const addr_of!(FOO));
 
 #[no_mangle]
 fn inline() {
-    unsafe { asm!("{}", const addr_of!(FOO)) };
-    //~^ ERROR invalid type for `const` operand
+    unsafe { asm!("/* {} */", const addr_of!(FOO)) };
 }
 
 fn main() {}

tests/ui/asm/const-refs-to-static.stderr

@@ -2,6 +2,8 @@
 //@ ignore-nvptx64
 //@ ignore-spirv
 
+#![feature(asm_const_ptr)]
+
 use std::arch::{asm, global_asm};
 
 // Const operands must be integers and must be constants.
@@ -12,21 +14,25 @@ global_asm!("{}", const 0i128);
 global_asm!("{}", const 0f32);
 //~^ ERROR invalid type for `const` operand
 global_asm!("{}", const 0 as *mut u8);
-//~^ ERROR invalid type for `const` operand
 
 fn test1() {
     unsafe {
-        // Const operands must be integers and must be constants.
+        // Const operands must be integers or thin pointers
 
         asm!("{}", const 0);
         asm!("{}", const 0i32);
         asm!("{}", const 0i128);
         asm!("{}", const 0f32);
         //~^ ERROR invalid type for `const` operand
         asm!("{}", const 0 as *mut u8);
-        //~^ ERROR invalid type for `const` operand
         asm!("{}", const &0);
+        asm!("{}", const b"Foo".as_slice());
         //~^ ERROR invalid type for `const` operand
+
+        asm!("{}", const test1 as fn());
+        asm!("{}", const test1);
+        asm!("{}", const (|| {}) as fn());
+        asm!("{}", const || {});
     }
 }