x86_64: efficient segmentation register save

Be slightly more efficient about saving segmentation
registers in traps.  Instead of writing to memory
twice (which probably doesn't _actually_ happen, but
who knows?) instead copy to an intermediate register
and then write to memory once.

Signed-off-by: Dan Cross <[email protected]>

Author: Dan Cross

x86_64/src/trap.rs

@@ -124,15 +124,6 @@ pub unsafe extern "C" fn trap() -> ! {
         asm!(r#"
             // Allocate space to save registers.
             subq $((4 + 15) * 8), %rsp
-            // Save the x86 segmentation registers.
-            movq $0, 18*8(%rsp);
-            movw %gs, 18*8(%rsp);
-            movq $0, 17*8(%rsp);
-            movw %fs, 17*8(%rsp);
-            movq $0, 16*8(%rsp);
-            movw %es, 16*8(%rsp);
-            movq $0, 15*8(%rsp);
-            movw %ds, 15*8(%rsp);
             // Save the general purpose registers.
             movq %r15, 14*8(%rsp);
             movq %r14, 13*8(%rsp);
@@ -149,6 +140,20 @@ pub unsafe extern "C" fn trap() -> ! {
             movq %rcx, 2*8(%rsp);
             movq %rbx, 1*8(%rsp);
             movq %rax, 0*8(%rsp);
+            // Save the x86 segmentation registers.  Uses %rdi
+            // as a scratch register, so we do this after we've
+            // saved the GP registers.  Note that we clear %rdi
+            // once, and then just move into the low bits and
+            // copy to the stack.
+            xorl %edi, %edi
+            movw %gs, %di;
+            movq %rdi, 18*8(%rsp);
+            movw %fs, %di;
+            movq %rdi, 17*8(%rsp);
+            movw %es, %di;
+            movq %rdi, 16*8(%rsp);
+            movw %ds, %di;
+            movq %rdi, 15*8(%rsp);
             // Fix up the vector number.  We got into `trap` via a
             // CALL, so hardware pushed the address after after the
             // CALLQ instruction onto the stack, and the byte at that