Implement asm_const_ptr for inline asm

Author: nbdd0121

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1230,14 +1230,19 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     InlineAsmOperandRef::InOut { reg, late, in_value, out_place }
                 }
                 mir::InlineAsmOperand::Const { ref value } => {
-                    let const_value = self.eval_mir_constant(value);
-                    let string = common::asm_const_to_str(
-                        bx.tcx(),
-                        span,
-                        const_value,
-                        bx.layout_of(value.ty()),
-                    );
-                    InlineAsmOperandRef::Interpolate { string }
+                    if value.ty().is_any_ptr() {
+                        let value = self.eval_mir_constant_to_operand(bx, value);
+                        InlineAsmOperandRef::Const { value }
+                    } else {
+                        let const_value = self.eval_mir_constant(value);
+                        let string = common::asm_const_to_str(
+                            bx.tcx(),
+                            span,
+                            const_value,
+                            bx.layout_of(value.ty()),
+                        );
+                        InlineAsmOperandRef::Interpolate { string }
+                    }
                 }
                 mir::InlineAsmOperand::SymFn { ref value } => {
                     let const_ = self.monomorphize(value.const_);

compiler/rustc_feature/src/unstable.rs

@@ -372,6 +372,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

@@ -11,6 +11,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

@@ -14,6 +14,13 @@ use rustc_span::{Ident, Span, Symbol};
 
 use crate::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>,
@@ -511,15 +511,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

@@ -474,6 +474,7 @@ symbols! {
         as_str,
         asm,
         asm_const,
+        asm_const_ptr,
         asm_experimental_arch,
         asm_experimental_reg,
         asm_goto,

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,7 +14,6 @@ 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 {
@@ -24,8 +25,7 @@ fn test1() {
         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
     }
 }

tests/ui/asm/invalid-const-operand.rs

@@ -35,55 +35,35 @@ LL +         const x: /* Type */ = 0;
    |
 
 error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:12:19
+  --> $DIR/invalid-const-operand.rs:14:19
    |
 LL | global_asm!("{}", const 0f32);
    |                   ^^^^^^----
    |                         |
    |                         is an `f32`
    |
-   = help: `const` operands must be of an integer type
-
-error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:14:19
-   |
-LL | global_asm!("{}", const 0 as *mut u8);
-   |                   ^^^^^^------------
-   |                         |
-   |                         is a `*mut u8`
-   |
-   = help: `const` operands must be of an integer type
+   = help: `const` operands must be of an integer or thin pointer type
 
 error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:24:20
+  --> $DIR/invalid-const-operand.rs:25:20
    |
 LL |         asm!("{}", const 0f32);
    |                    ^^^^^^----
    |                          |
    |                          is an `f32`
    |
-   = help: `const` operands must be of an integer type
-
-error: invalid type for `const` operand
-  --> $DIR/invalid-const-operand.rs:26:20
-   |
-LL |         asm!("{}", const 0 as *mut u8);
-   |                    ^^^^^^------------
-   |                          |
-   |                          is a `*mut u8`
-   |
-   = help: `const` operands must be of an integer type
+   = help: `const` operands must be of an integer or thin pointer type
 
 error: invalid type for `const` operand
   --> $DIR/invalid-const-operand.rs:28:20
    |
-LL |         asm!("{}", const &0);
-   |                    ^^^^^^--
+LL |         asm!("{}", const b"Foo".as_slice());
+   |                    ^^^^^^-----------------
    |                          |
-   |                          is a `&i32`
+   |                          is a `&[u8]`
    |
-   = help: `const` operands must be of an integer type
+   = help: `const` operands must be of an integer or thin pointer type
 
-error: aborting due to 8 previous errors
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0435`.