Overlap input and output stack slots

Author: nbdd0121

src/inline_asm.rs

@@ -306,19 +306,19 @@ impl<'tcx> InlineAssemblyGenerator<'_, 'tcx> {
         let mut slots_input = vec![None; self.operands.len()];
         let mut slots_output = vec![None; self.operands.len()];
 
-        let mut new_slot = |reg_class: InlineAsmRegClass| {
+        let new_slot_fn = |slot_size: &mut Size, reg_class: InlineAsmRegClass| {
             let reg_size = reg_class
                 .supported_types(InlineAsmArch::X86_64)
                 .iter()
                 .map(|(ty, _)| ty.size())
                 .max()
                 .unwrap();
             let align = rustc_target::abi::Align::from_bytes(reg_size.bytes()).unwrap();
-            slot_size = slot_size.align_to(align);
-            let offset = slot_size;
-            slot_size += reg_size;
+            let offset = slot_size.align_to(align);
+            *slot_size = offset + reg_size;
             offset
         };
+        let mut new_slot = |x| new_slot_fn(&mut slot_size, x);
 
         // Allocate stack slots for saving clobbered registers
         let abi_clobber =
@@ -346,30 +346,49 @@ impl<'tcx> InlineAssemblyGenerator<'_, 'tcx> {
             }
         }
 
-        // FIXME overlap input and output slots to save stack space
+        // Allocate stack slots for inout
         for (i, operand) in self.operands.iter().enumerate() {
             match *operand {
-                InlineAsmOperand::In { reg, .. } => {
-                    slots_input[i] = Some(new_slot(reg.reg_class()));
-                }
-                InlineAsmOperand::Out { reg, place, .. } => {
-                    if place.is_some() {
-                        slots_output[i] = Some(new_slot(reg.reg_class()));
-                    }
-                }
-                InlineAsmOperand::InOut { reg, out_place, .. } => {
+                InlineAsmOperand::InOut { reg, out_place: Some(_), .. } => {
                     let slot = new_slot(reg.reg_class());
                     slots_input[i] = Some(slot);
-                    if out_place.is_some() {
-                        slots_output[i] = Some(slot);
-                    }
+                    slots_output[i] = Some(slot);
+                }
+                _ => (),
+            }
+        }
+
+        let slot_size_before_input = slot_size;
+        let mut new_slot = |x| new_slot_fn(&mut slot_size, x);
+
+        // Allocate stack slots for input
+        for (i, operand) in self.operands.iter().enumerate() {
+            match *operand {
+                InlineAsmOperand::In { reg, .. }
+                | InlineAsmOperand::InOut { reg, out_place: None, .. } => {
+                    slots_input[i] = Some(new_slot(reg.reg_class()));
+                }
+                _ => (),
+            }
+        }
+
+        // Reset slot size
+        let slot_size_after_input = slot_size;
+        slot_size = slot_size_before_input;
+        let mut new_slot = |x| new_slot_fn(&mut slot_size, x);
+
+        // Allocate stack slots for output
+        for (i, operand) in self.operands.iter().enumerate() {
+            match *operand {
+                InlineAsmOperand::Out { reg, place: Some(_), .. } => {
+                    slots_output[i] = Some(new_slot(reg.reg_class()));
                 }
-                InlineAsmOperand::Const { value: _ } => (),
-                InlineAsmOperand::SymFn { value: _ } => (),
-                InlineAsmOperand::SymStatic { def_id: _ } => (),
+                _ => (),
             }
         }
 
+        slot_size = slot_size.max(slot_size_after_input);
+
         self.stack_slots_clobber = slots_clobber;
         self.stack_slots_input = slots_input;
         self.stack_slots_output = slots_output;