src/inline_asm.rs

   1 use crate::prelude::*;
   2
   3 use std::fmt::Write;
   4
   5 use rustc_ast::ast::{InlineAsmTemplatePiece, InlineAsmOptions};
   6 use rustc_middle::mir::InlineAsmOperand;
   7 use rustc_target::asm::*;
   8
   9 pub(crate) fn codegen_inline_asm<'tcx>(
  10     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
  11     _span: Span,
  12     template: &[InlineAsmTemplatePiece],
  13     operands: &[InlineAsmOperand<'tcx>],
  14     options: InlineAsmOptions,
  15 ) {
  16     // FIXME add .eh_frame unwind info directives
  17
  18     if template.is_empty() {
  19         // Black box
  20         return;
  21     }
  22
  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();
  27
  28     let mut new_slot = |reg_class: InlineAsmRegClass| {
  29         let reg_size = reg_class
  30             .supported_types(InlineAsmArch::X86_64)
  31             .iter()
  32             .map(|(ty, _)| ty.size())
  33             .max()
  34             .unwrap();
  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;
  39         offset
  40     };
  41
  42     // FIXME overlap input and output slots to save stack space
  43     for operand in operands {
  44         match *operand {
  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)));
  49             }
  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)));
  55                 }
  56             }
  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)));
  63                 }
  64             }
  65             InlineAsmOperand::Const { value: _ } => todo!(),
  66             InlineAsmOperand::SymFn { value: _ } => todo!(),
  67             InlineAsmOperand::SymStatic { def_id: _ } => todo!(),
  68         }
  69     }
  70
  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);
  74
  75     let generated_asm = generate_asm_wrapper(&asm_name, InlineAsmArch::X86_64, options, template, clobbered_regs, &inputs, &outputs);
  76     fx.global_asm.push_str(&generated_asm);
  77
  78     call_inline_asm(fx, &asm_name, slot_size, inputs, outputs);
  79 }
  80
  81 fn generate_asm_wrapper(
  82     asm_name: &str,
  83     arch: InlineAsmArch,
  84     options: InlineAsmOptions,
  85     template: &[InlineAsmTemplatePiece],
  86     clobbered_regs: Vec<(InlineAsmReg, Size)>,
  87     inputs: &[(InlineAsmReg, Size, Value)],
  88     outputs: &[(InlineAsmReg, Size, CPlace<'_>)],
  89 ) -> String {
  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();
  95
  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");
  99
 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);
 105         }
 106     }
 107
 108     // Write input registers
 109     for &(reg, offset, _value) in inputs {
 110         restore_register(&mut generated_asm, arch, reg, offset);
 111     }
 112
 113     if options.contains(InlineAsmOptions::ATT_SYNTAX) {
 114         generated_asm.push_str(".att_syntax\n");
 115     }
 116
 117     // The actual inline asm
 118     for piece in template {
 119         match piece {
 120             InlineAsmTemplatePiece::String(s) => {
 121                 generated_asm.push_str(s);
 122             }
 123             InlineAsmTemplatePiece::Placeholder { operand_idx: _, modifier: _, span: _ } => todo!(),
 124         }
 125     }
 126     generated_asm.push('\n');
 127
 128     if options.contains(InlineAsmOptions::ATT_SYNTAX) {
 129         generated_asm.push_str(".intel_syntax noprefix\n");
 130     }
 131
 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);
 136         }
 137
 138         // Restore clobbered registers
 139         for &(reg, offset) in clobbered_regs.iter().rev() {
 140             restore_register(&mut generated_asm, arch, reg, offset);
 141         }
 142
 143         generated_asm.push_str("    pop rbp\n");
 144         generated_asm.push_str("    ret\n");
 145     } else {
 146         generated_asm.push_str("    ud2\n");
 147     }
 148
 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");
 153
 154     generated_asm
 155 }
 156
 157 fn call_inline_asm<'tcx>(
 158     fx: &mut FunctionCx<'_, 'tcx, impl Backend>,
 159     asm_name: &str,
 160     slot_size: Size,
 161     inputs: Vec<(InlineAsmReg, Size, Value)>,
 162     outputs: Vec<(InlineAsmReg, Size, CPlace<'tcx>)>,
 163 ) {
 164     let stack_slot = fx.bcx.func.create_stack_slot(StackSlotData {
 165         kind: StackSlotKind::ExplicitSlot,
 166         offset: None,
 167         size: u32::try_from(slot_size.bytes()).unwrap(),
 168     });
 169     #[cfg(debug_assertions)]
 170     fx.add_comment(stack_slot, "inline asm scratch slot");
 171
 172     let inline_asm_func = fx.module.declare_function(asm_name, Linkage::Import, &Signature {
 173         call_conv: CallConv::SystemV,
 174         params: vec![AbiParam::new(fx.pointer_type)],
 175         returns: vec![],
 176     }).unwrap();
 177     let inline_asm_func = fx.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);
 180
 181     for (_reg, offset, value) in inputs {
 182         fx.bcx.ins().stack_store(value, stack_slot, i32::try_from(offset.bytes()).unwrap());
 183     }
 184
 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]);
 187
 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()));
 192     }
 193 }
 194
 195 fn expect_reg(reg_or_class: InlineAsmRegOrRegClass) -> InlineAsmReg {
 196     match reg_or_class {
 197         InlineAsmRegOrRegClass::Reg(reg) => reg,
 198         InlineAsmRegOrRegClass::RegClass(class) => unimplemented!("{:?}", class),
 199     }
 200 }
 201
 202 fn save_register(generated_asm: &mut String, arch: InlineAsmArch, reg: InlineAsmReg, offset: Size) {
 203     match arch {
 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');
 208         }
 209         _ => unimplemented!("save_register for {:?}", arch),
 210     }
 211 }
 212
 213 fn restore_register(generated_asm: &mut String, arch: InlineAsmArch, reg: InlineAsmReg, offset: Size) {
 214     match arch {
 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();
 219         }
 220         _ => unimplemented!("restore_register for {:?}", arch),
 221     }
 222 }