create a FunctionCx and properly evaluate consts

Author: folkertdev

compiler/rustc_codegen_ssa/src/mir/mod.rs

@@ -167,16 +167,37 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
 
     let llfn = cx.get_fn(instance);
 
-    if cx.tcx().has_attr(instance.def.def_id(), rustc_span::sym::naked) {
-        crate::mir::naked_asm::codegen_naked_asm::<Bx>(cx, instance);
-        return;
-    }
-
     let mir = cx.tcx().instance_mir(instance.def);
 
     let fn_abi = cx.fn_abi_of_instance(instance, ty::List::empty());
     debug!("fn_abi: {:?}", fn_abi);
 
+    if cx.tcx().has_attr(instance.def.def_id(), rustc_span::sym::naked) {
+        let cached_llbbs = IndexVec::new();
+
+        let fx: FunctionCx<'_, '_, Bx> = FunctionCx {
+            instance,
+            mir,
+            llfn,
+            fn_abi,
+            cx,
+            personality_slot: None,
+            cached_llbbs,
+            unreachable_block: None,
+            terminate_block: None,
+            cleanup_kinds: None,
+            landing_pads: IndexVec::from_elem(None, &mir.basic_blocks),
+            funclets: IndexVec::from_fn_n(|_| None, mir.basic_blocks.len()),
+            locals: locals::Locals::empty(),
+            debug_context: None,
+            per_local_var_debug_info: None,
+            caller_location: None,
+        };
+
+        fx.codegen_naked_asm(instance);
+        return;
+    }
+
     let debug_context = cx.create_function_debug_context(instance, fn_abi, llfn, mir);
 
     let start_llbb = Bx::append_block(cx, llfn, "start");

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -1,45 +1,75 @@
 use crate::common;
+use crate::mir::FunctionCx;
 use crate::traits::{AsmMethods, BuilderMethods, GlobalAsmOperandRef};
 use rustc_middle::bug;
-use rustc_middle::mir::{Const, InlineAsmOperand};
+use rustc_middle::mir::InlineAsmOperand;
 use rustc_middle::ty;
 use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf};
 use rustc_middle::ty::{Instance, TyCtxt};
 
 use rustc_span::sym;
 use rustc_target::asm::InlineAsmArch;
 
-pub fn codegen_naked_asm<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
-    cx: &'a Bx::CodegenCx,
-    instance: Instance<'tcx>,
-) {
-    let mir = cx.tcx().instance_mir(instance.def);
-
-    let rustc_middle::mir::TerminatorKind::InlineAsm {
-        template,
-        ref operands,
-        options,
-        line_spans,
-        targets: _,
-        unwind: _,
-    } = mir.basic_blocks.iter().next().unwrap().terminator().kind
-    else {
-        bug!("#[naked] functions should always terminate with an asm! block")
-    };
-
-    let operands: Vec<_> = operands
-        .iter()
-        .map(|op| crate::mir::naked_asm::inline_to_global_operand::<Bx>(cx, op))
-        .collect();
-
-    let (begin, end) = crate::mir::naked_asm::prefix_and_suffix(cx.tcx(), instance);
+impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
+    pub fn codegen_naked_asm(&self, instance: Instance<'tcx>) {
+        let cx = &self.cx;
+
+        let rustc_middle::mir::TerminatorKind::InlineAsm {
+            template,
+            ref operands,
+            options,
+            line_spans,
+            targets: _,
+            unwind: _,
+        } = self.mir.basic_blocks.iter().next().unwrap().terminator().kind
+        else {
+            bug!("#[naked] functions should always terminate with an asm! block")
+        };
+
+        let operands: Vec<_> =
+            operands.iter().map(|op| self.inline_to_global_operand(op)).collect();
+
+        let (begin, end) = crate::mir::naked_asm::prefix_and_suffix(cx.tcx(), instance);
+
+        let mut template_vec = Vec::new();
+        template_vec.push(rustc_ast::ast::InlineAsmTemplatePiece::String(begin));
+        template_vec.extend(template.iter().cloned());
+        template_vec.push(rustc_ast::ast::InlineAsmTemplatePiece::String(end));
+
+        cx.codegen_global_asm(&template_vec, &operands, options, line_spans);
+    }
 
-    let mut template_vec = Vec::new();
-    template_vec.push(rustc_ast::ast::InlineAsmTemplatePiece::String(begin));
-    template_vec.extend(template.iter().cloned());
-    template_vec.push(rustc_ast::ast::InlineAsmTemplatePiece::String(end));
+    fn inline_to_global_operand(&self, op: &InlineAsmOperand<'tcx>) -> GlobalAsmOperandRef<'tcx> {
+        match op {
+            InlineAsmOperand::Const { value } => {
+                let const_value = self.eval_mir_constant(value);
+                let string = common::asm_const_to_str(
+                    self.cx.tcx(),
+                    value.span,
+                    const_value,
+                    self.cx.layout_of(value.ty()),
+                );
+                GlobalAsmOperandRef::Const { string }
+            }
+            InlineAsmOperand::SymFn { value } => {
+                let instance = match value.ty().kind() {
+                    &ty::FnDef(def_id, args) => Instance::new(def_id, args),
+                    _ => bug!("asm sym is not a function"),
+                };
 
-    cx.codegen_global_asm(&template_vec, &operands, options, line_spans);
+                GlobalAsmOperandRef::SymFn { instance }
+            }
+            InlineAsmOperand::SymStatic { def_id } => {
+                GlobalAsmOperandRef::SymStatic { def_id: *def_id }
+            }
+            InlineAsmOperand::In { .. }
+            | InlineAsmOperand::Out { .. }
+            | InlineAsmOperand::InOut { .. }
+            | InlineAsmOperand::Label { .. } => {
+                bug!("invalid operand type for naked_asm!")
+            }
+        }
+    }
 }
 
 enum AsmBinaryFormat {
@@ -179,47 +209,3 @@ fn prefix_and_suffix<'tcx>(tcx: TyCtxt<'tcx>, instance: Instance<'tcx>) -> (Stri
 
     (begin, end)
 }
-
-fn inline_to_global_operand<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
-    cx: &'a Bx::CodegenCx,
-    op: &InlineAsmOperand<'tcx>,
-) -> GlobalAsmOperandRef<'tcx> {
-    match op {
-        InlineAsmOperand::Const { value } => match value.const_ {
-            Const::Ty(_ty, _const_) => todo!(),
-            Const::Unevaluated(_unevaluated_const, _ty) => todo!(),
-            Const::Val(const_value, ty) => {
-                let string = common::asm_const_to_str(
-                    cx.tcx(),
-                    value.span,
-                    const_value.clone(),
-                    cx.layout_of(ty),
-                );
-                GlobalAsmOperandRef::Const { string }
-            }
-        },
-        InlineAsmOperand::SymFn { value } => {
-            let instance = match value.const_ {
-                // &ty::FnDef(def_id, args) => Instance::new(def_id, args),
-                // _ => bug!("asm sym is not a function"),
-                Const::Ty(_ty, _const_) => todo!(),
-                Const::Unevaluated(_unevaluated_const, _ty) => todo!(),
-                Const::Val(_, ty) => match ty.kind() {
-                    ty::FnDef(def_id, args) => Instance::new(*def_id, *args),
-                    _ => bug!("asm sym is not a function"),
-                },
-            };
-
-            GlobalAsmOperandRef::SymFn { instance }
-        }
-        InlineAsmOperand::SymStatic { def_id } => {
-            GlobalAsmOperandRef::SymStatic { def_id: *def_id }
-        }
-        InlineAsmOperand::In { .. }
-        | InlineAsmOperand::Out { .. }
-        | InlineAsmOperand::InOut { .. }
-        | InlineAsmOperand::Label { .. } => {
-            bug!("invalid operand type for naked_asm!")
-        }
-    }
-}