5 use rustc_ast::ast::{InlineAsmTemplatePiece, InlineAsmOptions};
6 use rustc_middle::mir::InlineAsmOperand;
7 use rustc_target::asm::*;
9 pub(crate) fn codegen_inline_asm<'tcx>(
10 fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
12 template: &[InlineAsmTemplatePiece],
13 operands: &[InlineAsmOperand<'tcx>],
14 options: InlineAsmOptions,
16 // FIXME add .eh_frame unwind info directives
18 if template.is_empty() {
23 let mut slot_size = Size::from_bytes(0);
24 let mut clobbered_regs = Vec::new();
25 let mut inputs = Vec::new();
26 let mut outputs = Vec::new();
28 let mut new_slot = |reg_class: InlineAsmRegClass| {
29 let reg_size = reg_class
30 .supported_types(InlineAsmArch::X86_64)
32 .map(|(ty, _)| ty.size())
35 let align = rustc_target::abi::Align::from_bytes(reg_size.bytes()).unwrap();
36 slot_size = slot_size.align_to(align);
37 let offset = slot_size;
38 slot_size += reg_size;
42 // FIXME overlap input and output slots to save stack space
43 for operand in operands {
45 InlineAsmOperand::In { reg, ref value } => {
46 let reg = expect_reg(reg);
47 clobbered_regs.push((reg, new_slot(reg.reg_class())));
48 inputs.push((reg, new_slot(reg.reg_class()), crate::base::trans_operand(fx, value).load_scalar(fx)));
50 InlineAsmOperand::Out { reg, late: _, place } => {
51 let reg = expect_reg(reg);
52 clobbered_regs.push((reg, new_slot(reg.reg_class())));
53 if let Some(place) = place {
54 outputs.push((reg, new_slot(reg.reg_class()), crate::base::trans_place(fx, place)));
57 InlineAsmOperand::InOut { reg, late: _, ref in_value, out_place } => {
58 let reg = expect_reg(reg);
59 clobbered_regs.push((reg, new_slot(reg.reg_class())));
60 inputs.push((reg, new_slot(reg.reg_class()), crate::base::trans_operand(fx, in_value).load_scalar(fx)));
61 if let Some(out_place) = out_place {
62 outputs.push((reg, new_slot(reg.reg_class()), crate::base::trans_place(fx, out_place)));
65 InlineAsmOperand::Const { value: _ } => todo!(),
66 InlineAsmOperand::SymFn { value: _ } => todo!(),
67 InlineAsmOperand::SymStatic { def_id: _ } => todo!(),
71 let inline_asm_index = fx.inline_asm_index;
72 fx.inline_asm_index += 1;
73 let asm_name = format!("{}__inline_asm_{}", fx.tcx.symbol_name(fx.instance).name, inline_asm_index);
75 let generated_asm = generate_asm_wrapper(&asm_name, InlineAsmArch::X86_64, options, template, clobbered_regs, &inputs, &outputs);
76 fx.cx.global_asm.push_str(&generated_asm);
78 call_inline_asm(fx, &asm_name, slot_size, inputs, outputs);
81 fn generate_asm_wrapper(
84 options: InlineAsmOptions,
85 template: &[InlineAsmTemplatePiece],
86 clobbered_regs: Vec<(InlineAsmReg, Size)>,
87 inputs: &[(InlineAsmReg, Size, Value)],
88 outputs: &[(InlineAsmReg, Size, CPlace<'_>)],
90 let mut generated_asm = String::new();
91 writeln!(generated_asm, ".globl {}", asm_name).unwrap();
92 writeln!(generated_asm, ".type {},@function", asm_name).unwrap();
93 writeln!(generated_asm, ".section .text.{},\"ax\",@progbits", asm_name).unwrap();
94 writeln!(generated_asm, "{}:", asm_name).unwrap();
96 generated_asm.push_str(".intel_syntax noprefix\n");
97 generated_asm.push_str(" push rbp\n");
98 generated_asm.push_str(" mov rbp,rdi\n");
100 // Save clobbered registers
101 if !options.contains(InlineAsmOptions::NORETURN) {
102 // FIXME skip registers saved by the calling convention
103 for &(reg, offset) in &clobbered_regs {
104 save_register(&mut generated_asm, arch, reg, offset);
108 // Write input registers
109 for &(reg, offset, _value) in inputs {
110 restore_register(&mut generated_asm, arch, reg, offset);
113 if options.contains(InlineAsmOptions::ATT_SYNTAX) {
114 generated_asm.push_str(".att_syntax\n");
117 // The actual inline asm
118 for piece in template {
120 InlineAsmTemplatePiece::String(s) => {
121 generated_asm.push_str(s);
123 InlineAsmTemplatePiece::Placeholder { operand_idx: _, modifier: _, span: _ } => todo!(),
126 generated_asm.push('\n');
128 if options.contains(InlineAsmOptions::ATT_SYNTAX) {
129 generated_asm.push_str(".intel_syntax noprefix\n");
132 if !options.contains(InlineAsmOptions::NORETURN) {
133 // Read output registers
134 for &(reg, offset, _place) in outputs {
135 save_register(&mut generated_asm, arch, reg, offset);
138 // Restore clobbered registers
139 for &(reg, offset) in clobbered_regs.iter().rev() {
140 restore_register(&mut generated_asm, arch, reg, offset);
143 generated_asm.push_str(" pop rbp\n");
144 generated_asm.push_str(" ret\n");
146 generated_asm.push_str(" ud2\n");
149 generated_asm.push_str(".att_syntax\n");
150 writeln!(generated_asm, ".size {name}, .-{name}", name=asm_name).unwrap();
151 generated_asm.push_str(".text\n");
152 generated_asm.push_str("\n\n");
157 fn call_inline_asm<'tcx>(
158 fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
161 inputs: Vec<(InlineAsmReg, Size, Value)>,
162 outputs: Vec<(InlineAsmReg, Size, CPlace<'tcx>)>,
164 let stack_slot = fx.bcx.func.create_stack_slot(StackSlotData {
165 kind: StackSlotKind::ExplicitSlot,
167 size: u32::try_from(slot_size.bytes()).unwrap(),
169 #[cfg(debug_assertions)]
170 fx.add_comment(stack_slot, "inline asm scratch slot");
172 let inline_asm_func = fx.cx.module.declare_function(asm_name, Linkage::Import, &Signature {
173 call_conv: CallConv::SystemV,
174 params: vec![AbiParam::new(fx.pointer_type)],
177 let inline_asm_func = fx.cx.module.declare_func_in_func(inline_asm_func, &mut fx.bcx.func);
178 #[cfg(debug_assertions)]
179 fx.add_comment(inline_asm_func, asm_name);
181 for (_reg, offset, value) in inputs {
182 fx.bcx.ins().stack_store(value, stack_slot, i32::try_from(offset.bytes()).unwrap());
185 let stack_slot_addr = fx.bcx.ins().stack_addr(fx.pointer_type, stack_slot, 0);
186 fx.bcx.ins().call(inline_asm_func, &[stack_slot_addr]);
188 for (_reg, offset, place) in outputs {
189 let ty = fx.clif_type(place.layout().ty).unwrap();
190 let value = fx.bcx.ins().stack_load(ty, stack_slot, i32::try_from(offset.bytes()).unwrap());
191 place.write_cvalue(fx, CValue::by_val(value, place.layout()));
195 fn expect_reg(reg_or_class: InlineAsmRegOrRegClass) -> InlineAsmReg {
197 InlineAsmRegOrRegClass::Reg(reg) => reg,
198 InlineAsmRegOrRegClass::RegClass(class) => unimplemented!("{:?}", class),
202 fn save_register(generated_asm: &mut String, arch: InlineAsmArch, reg: InlineAsmReg, offset: Size) {
204 InlineAsmArch::X86_64 => {
205 write!(generated_asm, " mov [rbp+0x{:x}], ", offset.bytes()).unwrap();
206 reg.emit(generated_asm, InlineAsmArch::X86_64, None).unwrap();
207 generated_asm.push('\n');
209 _ => unimplemented!("save_register for {:?}", arch),
213 fn restore_register(generated_asm: &mut String, arch: InlineAsmArch, reg: InlineAsmReg, offset: Size) {
215 InlineAsmArch::X86_64 => {
216 generated_asm.push_str(" mov ");
217 reg.emit(generated_asm, InlineAsmArch::X86_64, None).unwrap();
218 writeln!(generated_asm, ", [rbp+0x{:x}]", offset.bytes()).unwrap();
220 _ => unimplemented!("restore_register for {:?}", arch),