Support codegen of asm const pointers without provenance

CTFE pointers created via type ID, `without_provenance` or pointers to const
ZSTs can now be codegenned with all 3 backends. These pointers are generated
in the same way as integers.

Author: nbdd0121

compiler/rustc_codegen_cranelift/src/global_asm.rs

@@ -114,7 +114,6 @@ fn codegen_global_asm_inner<'tcx>(
                             ConstScalar::Int(int) => {
                                 let string = rustc_codegen_ssa::common::asm_const_to_str(
                                     tcx,
-                                    span,
                                     int,
                                     FullyMonomorphizedLayoutCx(tcx).layout_of(ty),
                                 );

compiler/rustc_codegen_cranelift/src/inline_asm.rs

@@ -104,7 +104,6 @@ pub(crate) fn codegen_inline_asm_terminator<'tcx>(
 
                 let value = rustc_codegen_ssa::common::asm_const_to_str(
                     fx.tcx,
-                    span,
                     scalar.assert_scalar_int(),
                     fx.layout_of(ty),
                 );

compiler/rustc_codegen_gcc/src/asm.rs

@@ -453,7 +453,7 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                         template_str.push_str(escaped_char);
                     }
                 }
-                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier, span } => {
+                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier, span: _ } => {
                     let mut push_to_template = |modifier, gcc_idx| {
                         use std::fmt::Write;
 
@@ -501,7 +501,6 @@ impl<'a, 'gcc, 'tcx> AsmBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tcx> {
                                     // Const operands get injected directly into the template
                                     let string = rustc_codegen_ssa::common::asm_const_to_str(
                                         self.tcx,
-                                        span,
                                         int,
                                         self.layout_of(ty),
                                     );
@@ -909,7 +908,7 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                             .unwrap_or(string.len());
                     }
                 }
-                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span } => {
+                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span: _ } => {
                     match operands[operand_idx] {
                         GlobalAsmOperandRef::Const { value, ty } => {
                             match value {
@@ -919,7 +918,6 @@ impl<'gcc, 'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
                                     // here unlike normal inline assembly.
                                     let string = rustc_codegen_ssa::common::asm_const_to_str(
                                         self.tcx,
-                                        span,
                                         int,
                                         self.layout_of(ty),
                                     );

compiler/rustc_codegen_llvm/src/asm.rs

@@ -197,7 +197,7 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                         template_str.push_str(s)
                     }
                 }
-                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier, span } => {
+                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier, span: _ } => {
                     match operands[operand_idx] {
                         InlineAsmOperandRef::In { reg, .. }
                         | InlineAsmOperandRef::Out { reg, .. }
@@ -218,7 +218,6 @@ impl<'ll, 'tcx> AsmBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                                     // Const operands get injected directly into the template
                                     let string = rustc_codegen_ssa::common::asm_const_to_str(
                                         self.tcx,
-                                        span,
                                         int,
                                         self.layout_of(ty),
                                     );
@@ -430,7 +429,7 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
         for piece in template {
             match *piece {
                 InlineAsmTemplatePiece::String(ref s) => template_str.push_str(s),
-                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span } => {
+                InlineAsmTemplatePiece::Placeholder { operand_idx, modifier: _, span: _ } => {
                     match operands[operand_idx] {
                         GlobalAsmOperandRef::Const { value, ty } => {
                             match value {
@@ -440,7 +439,6 @@ impl<'tcx> AsmCodegenMethods<'tcx> for CodegenCx<'_, 'tcx> {
                                     // here unlike normal inline assembly.
                                     let string = rustc_codegen_ssa::common::asm_const_to_str(
                                         self.tcx,
-                                        span,
                                         int,
                                         self.layout_of(ty),
                                     );

compiler/rustc_codegen_ssa/src/base.rs

@@ -418,7 +418,10 @@ where
                                     const_value
                                 )
                             };
-                            GlobalAsmOperandRef::Const { value: scalar, ty }
+                            GlobalAsmOperandRef::Const {
+                                value: common::asm_const_ptr_clean(cx.tcx(), scalar),
+                                ty,
+                            }
                         }
                         Err(ErrorHandled::Reported { .. }) => {
                             // An error has already been reported and

compiler/rustc_codegen_ssa/src/common.rs

@@ -2,9 +2,10 @@
 
 use rustc_hir::LangItem;
 use rustc_hir::attrs::PeImportNameType;
+use rustc_middle::bug;
+use rustc_middle::mir::interpret::{GlobalAlloc, PointerArithmetic, Scalar};
 use rustc_middle::ty::layout::TyAndLayout;
 use rustc_middle::ty::{self, Instance, ScalarInt, TyCtxt};
-use rustc_middle::{bug, span_bug};
 use rustc_session::cstore::{DllCallingConvention, DllImport};
 use rustc_span::Span;
 use rustc_target::spec::{Abi, Env, Os, Target};
@@ -148,7 +149,6 @@ pub(crate) fn shift_mask_val<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
 pub fn asm_const_to_str<'tcx>(
     tcx: TyCtxt<'tcx>,
-    sp: Span,
     scalar: ScalarInt,
     ty_and_layout: TyAndLayout<'tcx>,
 ) -> String {
@@ -163,7 +163,34 @@ pub fn asm_const_to_str<'tcx>(
             ty::IntTy::I128 => (value as i128).to_string(),
             ty::IntTy::Isize => unreachable!(),
         },
-        _ => span_bug!(sp, "asm const has bad type {}", ty_and_layout.ty),
+        // For unsigned integers or pointers without provenance, just print the unsigned value
+        _ => value.to_string(),
+    }
+}
+
+/// "Clean" a const pointer by removing values where the resulting ASM will not be
+/// `<symbol> + <offset>`.
+///
+/// These values are converted to `ScalarInt`.
+pub fn asm_const_ptr_clean<'tcx>(tcx: TyCtxt<'tcx>, scalar: Scalar) -> Scalar {
+    let Scalar::Ptr(ptr, _) = scalar else {
+        return scalar;
+    };
+    let (prov, offset) = ptr.prov_and_relative_offset();
+    let global_alloc = tcx.global_alloc(prov.alloc_id());
+    match global_alloc {
+        GlobalAlloc::TypeId { .. } => {
+            // `TypeId` provenances are not a thing in codegen. Just erase and replace with scalar offset.
+            Scalar::from_u64(offset.bytes())
+        }
+        GlobalAlloc::Memory(alloc) if alloc.inner().len() == 0 => {
+            // ZST const allocations don't actually get global defined when lowered.
+            // Turn them into integer without provenances now.
+            let val = alloc.inner().align.bytes().wrapping_add(offset.bytes());
+            Scalar::from_target_usize(tcx.truncate_to_target_usize(val), &tcx)
+        }
+        // Other types of `GlobalAlloc` are fine.
+        _ => scalar,
     }
 }
 

compiler/rustc_codegen_ssa/src/mir/block.rs

@@ -1276,7 +1276,10 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                             const_value
                         )
                     };
-                    InlineAsmOperandRef::Const { value: scalar, ty: value.ty() }
+                    InlineAsmOperandRef::Const {
+                        value: common::asm_const_ptr_clean(bx.tcx(), scalar),
+                        ty: value.ty(),
+                    }
                 }
                 mir::InlineAsmOperand::SymFn { ref value } => {
                     let const_ = self.monomorphize(value.const_);

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -10,6 +10,7 @@ use rustc_span::sym;
 use rustc_target::callconv::{ArgAbi, FnAbi, PassMode};
 use rustc_target::spec::{Arch, BinaryFormat};
 
+use crate::common;
 use crate::mir::AsmCodegenMethods;
 use crate::traits::GlobalAsmOperandRef;
 
@@ -84,7 +85,10 @@ fn inline_to_global_operand<'a, 'tcx, Cx: LayoutOf<'tcx, LayoutOfResult = TyAndL
                 )
             };
 
-            GlobalAsmOperandRef::Const { value: scalar, ty: mono_type }
+            GlobalAsmOperandRef::Const {
+                value: common::asm_const_ptr_clean(cx.tcx(), scalar),
+                ty: mono_type,
+            }
         }
         InlineAsmOperand::SymFn { value } => {
             let mono_type = instance.instantiate_mir_and_normalize_erasing_regions(