Rollup merge of rust-lang#138618 - nbdd0121:asm_const_ptr, r=compiler-errors

Support using const pointers in asm `const` operand

Implements rust-lang#128464

This adds support of const pointers for asm `const` in addition to plain integers.

The inline `asm!` support is implemented using `i` constraint, and the `global_asm!` and `naked_asm!` support is implemented by inserting `symbol + offset` and make `symbol` compiler-used. For unnamed consts, it will create additional internal & hidden symbols so that they can be referenced by global_asm.

The feature is also implemented for GCC backend but it's untested.

Author: samueltardieu

compiler/rustc_codegen_cranelift/src/global_asm.rs

@@ -8,10 +8,10 @@ use std::sync::Arc;
 
 use rustc_ast::{InlineAsmOptions, InlineAsmTemplatePiece};
 use rustc_codegen_ssa::traits::{AsmCodegenMethods, GlobalAsmOperandRef};
-use rustc_middle::ty::TyCtxt;
 use rustc_middle::ty::layout::{
     FnAbiError, FnAbiOfHelpers, FnAbiRequest, HasTyCtxt, HasTypingEnv, LayoutError, LayoutOfHelpers,
 };
+use rustc_middle::ty::{Instance, TyCtxt};
 use rustc_session::config::{OutputFilenames, OutputType};
 use rustc_target::asm::InlineAsmArch;
 
@@ -29,6 +29,7 @@ impl<'tcx> AsmCodegenMethods<'tcx> for GlobalAsmContext<'_, 'tcx> {
         operands: &[GlobalAsmOperandRef<'tcx>],
         options: InlineAsmOptions,
         _line_spans: &[Span],
+        _instance: Instance<'_>,
     ) {
         codegen_global_asm_inner(self.tcx, self.global_asm, template, operands, options);
     }
@@ -104,7 +105,7 @@ fn codegen_global_asm_inner<'tcx>(
             InlineAsmTemplatePiece::String(ref s) => global_asm.push_str(s),
             InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span } => {
                 match operands[operand_idx] {
-                    GlobalAsmOperandRef::Const { ref string } => {
+                    GlobalAsmOperandRef::Interpolate { ref string } => {
                         global_asm.push_str(string);
                     }
                     GlobalAsmOperandRef::SymFn { instance } => {
@@ -132,6 +133,12 @@ fn codegen_global_asm_inner<'tcx>(
                         let symbol = tcx.symbol_name(instance);
                         global_asm.push_str(symbol.name);
                     }
+                    GlobalAsmOperandRef::ConstPointer { value: _ } => {
+                        tcx.dcx().span_err(
+                            span,
+                            "asm! and global_asm! const pointer operands are not yet supported",
+                        );
+                    }
                 }
             }
         }

compiler/rustc_codegen_gcc/src/asm.rs

@@ -2,16 +2,16 @@
 
 use std::borrow::Cow;
 
-use gccjit::{LValue, RValue, ToRValue, Type};
+use gccjit::{GlobalKind, LValue, RValue, ToRValue, Type};
 use rustc_ast::ast::{InlineAsmOptions, InlineAsmTemplatePiece};
 use rustc_codegen_ssa::mir::operand::OperandValue;
 use rustc_codegen_ssa::mir::place::PlaceRef;
 use rustc_codegen_ssa::traits::{
     AsmBuilderMethods, AsmCodegenMethods, BaseTypeCodegenMethods, BuilderMethods,
     GlobalAsmOperandRef, InlineAsmOperandRef,
 };
-use rustc_middle::bug;
 use rustc_middle::ty::Instance;
+use rustc_middle::{bug, mir};
 use rustc_span::Span;
 use rustc_target::asm::*;
 
@@ -296,10 +296,18 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     }
                 }
 
-                InlineAsmOperandRef::Const { ref string } => {
+                InlineAsmOperandRef::Interpolate { ref string } => {
                     constants_len += string.len() + att_dialect as usize;
                 }
 
+                InlineAsmOperandRef::Const { value } => {
+                    inputs.push(AsmInOperand {
+                        constraint: Cow::Borrowed("i"),
+                        rust_idx,
+                        val: value.immediate(),
+                    });
+                }
+
                 InlineAsmOperandRef::SymFn { instance } => {
                     // TODO(@Amanieu): Additional mangling is needed on
                     // some targets to add a leading underscore (Mach-O)
@@ -411,6 +419,10 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                     });
                 }
 
+                InlineAsmOperandRef::Interpolate { .. } => {
+                    // processed in the previous pass
+                }
+
                 InlineAsmOperandRef::Const { .. } => {
                     // processed in the previous pass
                 }
@@ -488,6 +500,15 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                             push_to_template(modifier, gcc_index);
                         }
 
+                        InlineAsmOperandRef::Const { .. } => {
+                            let in_gcc_index = inputs
+                                .iter()
+                                .position(|op| operand_idx == op.rust_idx)
+                                .expect("wrong rust index");
+                            let gcc_index = in_gcc_index + outputs.len();
+                            push_to_template(None, gcc_index);
+                        }
+
                         InlineAsmOperandRef::SymFn { instance } => {
                             // TODO(@Amanieu): Additional mangling is needed on
                             // some targets to add a leading underscore (Mach-O)
@@ -504,7 +525,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                             template_str.push_str(name);
                         }
 
-                        InlineAsmOperandRef::Const { ref string } => {
+                        InlineAsmOperandRef::Interpolate { ref string } => {
                             template_str.push_str(string);
                         }
 
@@ -837,13 +858,110 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
         operands: &[GlobalAsmOperandRef<'tcx>],
         options: InlineAsmOptions,
         _line_spans: &[Span],
+        instance: Instance<'tcx>,
     ) {
         let asm_arch = self.tcx.sess.asm_arch.unwrap();
 
         // Default to Intel syntax on x86
         let att_dialect = matches!(asm_arch, InlineAsmArch::X86 | InlineAsmArch::X86_64)
             && options.contains(InlineAsmOptions::ATT_SYNTAX);
 
+        // Convert all operands to string interpolations
+        let converted_operands = operands
+            .iter()
+            .enumerate()
+            .map(|(operand_idx, operand)| {
+                match *operand {
+                    GlobalAsmOperandRef::Interpolate { ref string } => {
+                        // Const operands get injected directly into the
+                        // template. Note that we don't need to escape $
+                        // here unlike normal inline assembly.
+                        string.to_owned()
+                    }
+                    GlobalAsmOperandRef::ConstPointer { value } => {
+                        let (prov, offset) = value.prov_and_relative_offset();
+                        let global_alloc = self.tcx.global_alloc(prov.alloc_id());
+                        let symbol = 'sym: {
+                            let alloc = match global_alloc {
+                                mir::interpret::GlobalAlloc::Function { instance } => {
+                                    let function = get_fn(self, instance);
+                                    self.add_used_function(function);
+                                    // TODO(@Amanieu): Additional mangling is needed on
+                                    // some targets to add a leading underscore (Mach-O)
+                                    // or byte count suffixes (x86 Windows).
+                                    break 'sym self.tcx.symbol_name(instance).name.to_owned();
+                                }
+                                mir::interpret::GlobalAlloc::VTable(ty, dyn_ty) => self
+                                    .tcx
+                                    .global_alloc(self.tcx.vtable_allocation((
+                                        ty,
+                                        dyn_ty.principal().map(|principal| {
+                                            self.tcx
+                                                .instantiate_bound_regions_with_erased(principal)
+                                        }),
+                                    )))
+                                    .unwrap_memory(),
+                                mir::interpret::GlobalAlloc::Static(def_id) => {
+                                    // TODO(antoyo): set the global variable as used.
+                                    // TODO(@Amanieu): Additional mangling is needed on
+                                    // some targets to add a leading underscore (Mach-O).
+                                    let instance = Instance::mono(self.tcx, def_id);
+                                    break 'sym self.tcx.symbol_name(instance).name.to_owned();
+                                }
+                                mir::interpret::GlobalAlloc::Memory(alloc) => alloc,
+                                mir::interpret::GlobalAlloc::TypeId { .. } => {
+                                    // This is not an actual allocation, just return the offset.
+                                    return format!("{}", offset.bytes());
+                                }
+                            };
+
+                            // For ZSTs directly codegen an aligned pointer.
+                            if alloc.inner().len() == 0 {
+                                assert_eq!(offset.bytes(), 0);
+                                return format!("{}", alloc.inner().align.bytes());
+                            }
+
+                            let asm_name = self.tcx.symbol_name(instance);
+                            let sym_name = format!("{asm_name}.{operand_idx}");
+
+                            let init = crate::consts::const_alloc_to_gcc_uncached(self, alloc);
+                            let alloc = alloc.inner();
+                            let typ = self.val_ty(init).get_aligned(alloc.align.bytes());
+
+                            let global = self.declare_global_with_linkage(
+                                &sym_name,
+                                typ,
+                                GlobalKind::Exported,
+                            );
+                            global.global_set_initializer_rvalue(init);
+                            // TODO(nbdd0121): set unnamed address.
+                            // TODO(nbdd0121): set the global variable as used.
+
+                            sym_name
+                        };
+
+                        let offset = offset.bytes();
+                        if offset != 0 { format!("{symbol}+{offset}") } else { symbol }
+                    }
+                    GlobalAsmOperandRef::SymFn { instance } => {
+                        let function = get_fn(self, instance);
+                        self.add_used_function(function);
+                        // TODO(@Amanieu): Additional mangling is needed on
+                        // some targets to add a leading underscore (Mach-O)
+                        // or byte count suffixes (x86 Windows).
+                        self.tcx.symbol_name(instance).name.to_owned()
+                    }
+                    GlobalAsmOperandRef::SymStatic { def_id } => {
+                        // TODO(antoyo): set the global variable as used.
+                        // TODO(@Amanieu): Additional mangling is needed on
+                        // some targets to add a leading underscore (Mach-O).
+                        let instance = Instance::mono(self.tcx, def_id);
+                        self.tcx.symbol_name(instance).name.to_owned()
+                    }
+                }
+            })
+            .collect::<Vec<_>>();
+
         // Build the template string
         let mut template_str = ".pushsection .text\n".to_owned();
         if att_dialect {
@@ -867,33 +985,7 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                     }
                 }
                 InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span: _ } => {
-                    match operands[operand_idx] {
-                        GlobalAsmOperandRef::Const { ref string } => {
-                            // Const operands get injected directly into the
-                            // template. Note that we don't need to escape %
-                            // here unlike normal inline assembly.
-                            template_str.push_str(string);
-                        }
-
-                        GlobalAsmOperandRef::SymFn { instance } => {
-                            let function = get_fn(self, instance);
-                            self.add_used_function(function);
-                            // TODO(@Amanieu): Additional mangling is needed on
-                            // some targets to add a leading underscore (Mach-O)
-                            // or byte count suffixes (x86 Windows).
-                            let name = self.tcx.symbol_name(instance).name;
-                            template_str.push_str(name);
-                        }
-
-                        GlobalAsmOperandRef::SymStatic { def_id } => {
-                            // TODO(antoyo): set the global variable as used.
-                            // TODO(@Amanieu): Additional mangling is needed on
-                            // some targets to add a leading underscore (Mach-O).
-                            let instance = Instance::mono(self.tcx, def_id);
-                            let name = self.tcx.symbol_name(instance).name;
-                            template_str.push_str(name);
-                        }
-                    }
+                    template_str.push_str(&converted_operands[operand_idx]);
                 }
             }
         }