code review 5279048: runtime: faster and more scalable GC

src/pkg/runtime/asm_amd64.s

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 #include "zasm_GOOS_GOARCH.h"
 
 TEXT _rt0_amd64(SB),7,$-8
         // copy arguments forward on an even stack
         MOVQ    0(DI), AX               // argc
         LEAQ    8(DI), BX               // argv
@@ skipping 326 matching lines @@
         MOVL    16(SP), AX
         MOVL    20(SP), CX
         LOCK
         CMPXCHGL        CX, 0(BX)
         JZ 3(PC)
         MOVL    $0, AX
         RET
         MOVL    $1, AX
         RET
 
+// bool runtime·cas64(uint64 *val, uint64 *old, uint64 new)
+// Atomically:
+//      if(*val == *old){
+//              *val = new;
+//              return 1;
+//      } else {
+//              *old = *val
+//              return 0;
+//      }
+TEXT runtime·cas64(SB), 7, $0
+        MOVQ    8(SP), BX
+        MOVQ    16(SP), BP
+        MOVQ    0(BP), AX
+        MOVQ    24(SP), CX
+        LOCK
+        CMPXCHGQ        CX, 0(BX)
+        JNZ     cas64_fail
+        MOVL    $1, AX
+        RET
+cas64_fail:
+        MOVQ    AX, 0(BP)
+        XORL    AX, AX
+        RET
+
 // bool casp(void **val, void *old, void *new)
 // Atomically:
 //      if(*val == old){
 //              *val = new;
 //              return 1;
 //      } else
 //              return 0;
 TEXT runtime·casp(SB), 7, $0
         MOVQ    8(SP), BX
         MOVQ    16(SP), AX
@@ skipping 12 matching lines @@
 //      return *val;
 TEXT runtime·xadd(SB), 7, $0
         MOVQ    8(SP), BX
         MOVL    16(SP), AX
         MOVL    AX, CX
         LOCK
         XADDL   AX, 0(BX)
         ADDL    CX, AX
         RET
 
+TEXT runtime·xadd64(SB), 7, $0
+        MOVQ    8(SP), BX
+        MOVQ    16(SP), AX
+        MOVQ    AX, CX
+        LOCK
+        XADDQ   AX, 0(BX)
+        ADDQ    CX, AX
+        RET
+
 TEXT runtime·xchg(SB), 7, $0
         MOVQ    8(SP), BX
         MOVL    16(SP), AX
         XCHGL   AX, 0(BX)
         RET
 
 TEXT runtime·procyield(SB),7,$0
         MOVL    8(SP), AX
 again:
         PAUSE
         SUBL    $1, AX
         JNZ     again
         RET
 
 TEXT runtime·atomicstorep(SB), 7, $0
         MOVQ    8(SP), BX
         MOVQ    16(SP), AX
         XCHGQ   AX, 0(BX)
         RET
 
 TEXT runtime·atomicstore(SB), 7, $0
         MOVQ    8(SP), BX
         MOVL    16(SP), AX
         XCHGL   AX, 0(BX)
+        RET
+
+TEXT runtime·atomicstore64(SB), 7, $0
+        MOVQ    8(SP), BX
+        MOVQ    16(SP), AX
+        XCHGQ   AX, 0(BX)
+        RET
+
+TEXT runtime·prefetch(SB), 7, $0
+        MOVQ    8(SP), AX
+        // PREFETCHNTA (AX)
+        BYTE $0x0f; BYTE $0x18; BYTE $0x00
         RET
 
 // void jmpdefer(fn, sp);
 // called from deferreturn.
 // 1. pop the caller
 // 2. sub 5 bytes from the callers return
 // 3. jmp to the argument
 TEXT runtime·jmpdefer(SB), 7, $0
         MOVQ    8(SP), AX       // fn
         MOVQ    16(SP), BX      // caller sp
@@ skipping 177 matching lines @@
 TEXT runtime·stackguard(SB),7,$0
         MOVQ    SP, DX
         MOVQ    DX, sp+0(FP)
         get_tls(CX)
         MOVQ    g(CX), BX
         MOVQ    g_stackguard(BX), DX
         MOVQ    DX, guard+8(FP)
         RET
 
 GLOBL runtime·tls0(SB), $64