Always bounce mul/div/mod ops. Closes #131 harder.

Author: graydon

src/Makefile

@@ -385,11 +385,7 @@ TASK_XFAILS := test/run-pass/acyclic-unwind.rs \
                test/run-pass/threads.rs \
                test/run-pass/yield.rs
 
-TEST_XFAILS := test/run-pass/arith-0.rs
-
 TEST_XFAILS_X86 :=  $(TASK_XFAILS) \
-					$(TEST_XFAILS) \
-                    test/run-pass/arithmetic-interference.rs \
                     test/run-pass/bind-obj-ctor.rs \
                     test/run-pass/child-outlives-parent.rs \
                     test/run-pass/clone-with-exterior.rs \
@@ -419,13 +415,11 @@ TEST_XFAILS_X86 :=  $(TASK_XFAILS) \
                     test/compile-fail/writing-through-read-alias.rs
 
 TEST_XFAILS_LLVM := $(TASK_XFAILS) \
-					$(TEST_XFAILS) \
                     $(addprefix test/run-pass/, \
                       arith-1.rs \
                       acyclic-unwind.rs \
                       alt-pattern-simple.rs \
                       alt-tag.rs \
-                      arithmetic-interference.rs \
                       argv.rs \
                       autoderef-full-lval.rs \
                       autoderef-objfn.rs \

src/boot/be/x86.ml

@@ -303,48 +303,31 @@ let emit_target_specific
                   let dst_eax = hr_like_cell eax dst in
                   let lhs_eax = hr_like_op eax lhs in
                   let rhs_ecx = hr_like_op ecx rhs in
-                    (* Horrible: we bounce complex mul inputs off spill slots
+                    (* Horrible: we bounce mul/div/mod inputs off spill slots
                      * to ensure non-interference between the temporaries used
                      * during mem-base-reg reloads and the registers we're
                      * preparing.  *)
                   let next_spill_like op =
                     Il.Mem (Il.next_spill_slot e
                               (Il.ScalarTy (Il.operand_scalar_ty op)))
                   in
-                  let is_mem op =
-                    match op with
-                        Il.Cell (Il.Mem _) -> true
-                      | _ -> false
-                  in
-                  let bounce_lhs = is_mem lhs in
-                  let bounce_rhs = is_mem rhs in
                   let lhs_spill = next_spill_like lhs in
                   let rhs_spill = next_spill_like rhs in
 
-                    if bounce_lhs
-                    then mov lhs_spill lhs;
-
-                    if bounce_rhs
-                    then mov rhs_spill rhs;
+                    mov lhs_spill lhs;
+                    mov rhs_spill rhs;
 
-                    mov lhs_eax
-                      (if bounce_lhs
-                       then (Il.Cell lhs_spill)
-                       else lhs);
+                    mov lhs_eax (Il.Cell lhs_spill);
+                    mov rhs_ecx (Il.Cell rhs_spill);
 
-                    mov rhs_ecx
-                      (if bounce_rhs
-                       then (Il.Cell rhs_spill)
-                       else rhs);
-                    
                     put (Il.Binary
                            { b with
                                Il.binary_lhs = (Il.Cell lhs_eax);
                                Il.binary_rhs = (Il.Cell rhs_ecx);
                                Il.binary_dst = dst_eax; });
                     if dst <> dst_eax
                     then mov dst (Il.Cell dst_eax);
-                    
+
               | _ when (Il.Cell dst) <> lhs ->
                   mov dst lhs;
                   put (Il.Binary

src/boot/me/trans.ml

@@ -181,7 +181,7 @@ let trans_visitor
       match q with
         Il.Jmp _ -> flush_emitter_size_cache();
         | _ -> ()
-    end;        
+    end;
     Il.emit (emitter()) q
   in