code review 12568043: cmd/ld: Put the textflag constants in a separate file.

src/pkg/runtime/asm_386.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"
 #include "funcdata.h"
-
-TEXT _rt0_go(SB),7,$0
+#include "../../cmd/ld/textflag.h"
+
+TEXT _rt0_go(SB),NOSPLIT,$0
         // copy arguments forward on an even stack
         MOVL    argc+0(FP), AX
         MOVL    argv+4(FP), BX
         SUBL    $128, SP                // plenty of scratch
         ANDL    $~15, SP
         MOVL    AX, 120(SP)             // save argc, argv away
         MOVL    BX, 124(SP)
 
         // set default stack bounds.
         // _cgo_init may update stackguard.
@@ skipping 83 matching lines @@
         POPL    AX
         POPL    AX
 
         // start this M
         CALL    runtime·mstart(SB)
 
         INT $3
         RET
 
 DATA    runtime·main·f+0(SB)/4,$runtime·main(SB)
-GLOBL   runtime·main·f(SB),8,$4
-
-TEXT runtime·breakpoint(SB),7,$0-0
+GLOBL   runtime·main·f(SB),RODATA,$4
+
+TEXT runtime·breakpoint(SB),NOSPLIT,$0-0
         INT $3
         RET
 
-TEXT runtime·asminit(SB),7,$0-0
+TEXT runtime·asminit(SB),NOSPLIT,$0-0
         // Linux and MinGW start the FPU in extended double precision.
         // Other operating systems use double precision.
         // Change to double precision to match them,
         // and to match other hardware that only has double.
         PUSHL $0x27F
         FLDCW   0(SP)
         POPL AX
         RET
 
 /*
  *  go-routine
  */
 
 // void gosave(Gobuf*)
 // save state in Gobuf; setjmp
-TEXT runtime·gosave(SB), 7, $0-4
+TEXT runtime·gosave(SB), NOSPLIT, $0-4
         MOVL    4(SP), AX               // gobuf
         LEAL    4(SP), BX               // caller's SP
         MOVL    BX, gobuf_sp(AX)
         MOVL    0(SP), BX               // caller's PC
         MOVL    BX, gobuf_pc(AX)
         MOVL    $0, gobuf_ret(AX)
         MOVL    $0, gobuf_ctxt(AX)
         get_tls(CX)
         MOVL    g(CX), BX
         MOVL    BX, gobuf_g(AX)
         RET
 
 // void gogo(Gobuf*)
 // restore state from Gobuf; longjmp
-TEXT runtime·gogo(SB), 7, $0-4
+TEXT runtime·gogo(SB), NOSPLIT, $0-4
         MOVL    4(SP), BX               // gobuf
         MOVL    gobuf_g(BX), DX
         MOVL    0(DX), CX               // make sure g != nil
         get_tls(CX)
         MOVL    DX, g(CX)
         MOVL    gobuf_sp(BX), SP        // restore SP
         MOVL    gobuf_ret(BX), AX
         MOVL    gobuf_ctxt(BX), DX
         MOVL    $0, gobuf_sp(BX)        // clear to help garbage collector
         MOVL    $0, gobuf_ret(BX)
         MOVL    $0, gobuf_ctxt(BX)
         MOVL    gobuf_pc(BX), BX
         JMP     BX
 
 // void mcall(void (*fn)(G*))
 // Switch to m->g0's stack, call fn(g).
 // Fn must never return.  It should gogo(&g->sched)
 // to keep running g.
-TEXT runtime·mcall(SB), 7, $0-4
+TEXT runtime·mcall(SB), NOSPLIT, $0-4
         MOVL    fn+0(FP), DI
 ········
         get_tls(CX)
         MOVL    g(CX), AX       // save state in g->sched
         MOVL    0(SP), BX       // caller's PC
         MOVL    BX, (g_sched+gobuf_pc)(AX)
         LEAL    4(SP), BX       // caller's SP
         MOVL    BX, (g_sched+gobuf_sp)(AX)
         MOVL    AX, (g_sched+gobuf_g)(AX)
 
@@ skipping 14 matching lines @@
 /*
  * support for morestack
  */
 
 // Called during function prolog when more stack is needed.
 //
 // The traceback routines see morestack on a g0 as being
 // the top of a stack (for example, morestack calling newstack
 // calling the scheduler calling newm calling gc), so we must
 // record an argument size. For that purpose, it has no arguments.
-TEXT runtime·morestack(SB),7,$0-0
+TEXT runtime·morestack(SB),NOSPLIT,$0-0
         // Cannot grow scheduler stack (m->g0).
         get_tls(CX)
         MOVL    m(CX), BX
         MOVL    m_g0(BX), SI
         CMPL    g(CX), SI
         JNE     2(PC)
         INT     $3
 
         // frame size in DI
         // arg size in AX
@@ skipping 28 matching lines @@
         MOVL    AX, SP
         CALL    runtime·newstack(SB)
         MOVL    $0, 0x1003      // crash if newstack returns
         RET
 
 // Called from panic.  Mimics morestack,
 // reuses stack growth code to create a frame
 // with the desired args running the desired function.
 //
 // func call(fn *byte, arg *byte, argsize uint32).
-TEXT runtime·newstackcall(SB), 7, $0-12
+TEXT runtime·newstackcall(SB), NOSPLIT, $0-12
         get_tls(CX)
         MOVL    m(CX), BX
 
         // Save our caller's state as the PC and SP to
         // restore when returning from f.
         MOVL    0(SP), AX       // our caller's PC
         MOVL    AX, (m_morebuf+gobuf_pc)(BX)
         LEAL    4(SP), AX       // our caller's SP
         MOVL    AX, (m_morebuf+gobuf_sp)(BX)
         MOVL    g(CX), AX
@@ skipping 34 matching lines @@
 // of constant-sized-frame functions to encode a few bits of size in the pc.
 // Caution: ugly multiline assembly macros in your future!
 
 #define DISPATCH(NAME,MAXSIZE)          \
         CMPL    CX, $MAXSIZE;           \
         JA      3(PC);                  \
         MOVL    $runtime·NAME(SB), AX;  \
         JMP     AX
 // Note: can't just "JMP runtime·NAME(SB)" - bad inlining results.
 
-TEXT reflect·call(SB), 7, $0-12
+TEXT reflect·call(SB), NOSPLIT, $0-12
         MOVL    argsize+8(FP), CX
         DISPATCH(call16, 16)
         DISPATCH(call32, 32)
         DISPATCH(call64, 64)
         DISPATCH(call128, 128)
         DISPATCH(call256, 256)
         DISPATCH(call512, 512)
         DISPATCH(call1024, 1024)
         DISPATCH(call2048, 2048)
         DISPATCH(call4096, 4096)
@@ skipping 60 matching lines @@
 CALLFN(call67108864, 67108864)
 CALLFN(call134217728, 134217728)
 CALLFN(call268435456, 268435456)
 CALLFN(call536870912, 536870912)
 CALLFN(call1073741824, 1073741824)
 
 // Return point when leaving stack.
 //
 // Lessstack can appear in stack traces for the same reason
 // as morestack; in that context, it has 0 arguments.
-TEXT runtime·lessstack(SB), 7, $0-0
+TEXT runtime·lessstack(SB), NOSPLIT, $0-0
         // Save return value in m->cret
         get_tls(CX)
         MOVL    m(CX), BX
         MOVL    AX, m_cret(BX)
 
         // Call oldstack on m->g0's stack.
         MOVL    m_g0(BX), BP
         MOVL    BP, g(CX)
         MOVL    (g_sched+gobuf_sp)(BP), SP
         CALL    runtime·oldstack(SB)
         MOVL    $0, 0x1004      // crash if oldstack returns
         RET
 
 
 // bool cas(int32 *val, int32 old, int32 new)
 // Atomically:
 //      if(*val == old){
 //              *val = new;
 //              return 1;
 //      }else
 //              return 0;
-TEXT runtime·cas(SB), 7, $0-12
+TEXT runtime·cas(SB), NOSPLIT, $0-12
         MOVL    4(SP), BX
         MOVL    8(SP), AX
         MOVL    12(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 {
 //              return 0;
 //      }
-TEXT runtime·cas64(SB), 7, $0-20
+TEXT runtime·cas64(SB), NOSPLIT, $0-20
         MOVL    4(SP), BP
         MOVL    8(SP), AX
         MOVL    12(SP), DX
         MOVL    16(SP), BX
         MOVL    20(SP), CX
         LOCK
         CMPXCHG8B       0(BP)
         JNZ     cas64_fail
         MOVL    $1, AX
         RET
 cas64_fail:
         MOVL    $0, AX
         RET
 
 // bool casp(void **p, void *old, void *new)
 // Atomically:
 //      if(*p == old){
 //              *p = new;
 //              return 1;
 //      }else
 //              return 0;
-TEXT runtime·casp(SB), 7, $0-12
+TEXT runtime·casp(SB), NOSPLIT, $0-12
         MOVL    4(SP), BX
         MOVL    8(SP), AX
         MOVL    12(SP), CX
         LOCK
         CMPXCHGL        CX, 0(BX)
         JZ 3(PC)
         MOVL    $0, AX
         RET
         MOVL    $1, AX
         RET
 
 // uint32 xadd(uint32 volatile *val, int32 delta)
 // Atomically:
 //      *val += delta;
 //      return *val;
-TEXT runtime·xadd(SB), 7, $0-8
+TEXT runtime·xadd(SB), NOSPLIT, $0-8
         MOVL    4(SP), BX
         MOVL    8(SP), AX
         MOVL    AX, CX
         LOCK
         XADDL   AX, 0(BX)
         ADDL    CX, AX
         RET
 
-TEXT runtime·xchg(SB), 7, $0-8
+TEXT runtime·xchg(SB), NOSPLIT, $0-8
         MOVL    4(SP), BX
         MOVL    8(SP), AX
         XCHGL   AX, 0(BX)
         RET
 
-TEXT runtime·procyield(SB),7,$0-0
+TEXT runtime·procyield(SB),NOSPLIT,$0-0
         MOVL    4(SP), AX
 again:
         PAUSE
         SUBL    $1, AX
         JNZ     again
         RET
 
-TEXT runtime·atomicstorep(SB), 7, $0-8
+TEXT runtime·atomicstorep(SB), NOSPLIT, $0-8
         MOVL    4(SP), BX
         MOVL    8(SP), AX
         XCHGL   AX, 0(BX)
         RET
 
-TEXT runtime·atomicstore(SB), 7, $0-8
+TEXT runtime·atomicstore(SB), NOSPLIT, $0-8
         MOVL    4(SP), BX
         MOVL    8(SP), AX
         XCHGL   AX, 0(BX)
         RET
 
 // uint64 atomicload64(uint64 volatile* addr);
 // so actually
 // void atomicload64(uint64 *res, uint64 volatile *addr);
-TEXT runtime·atomicload64(SB), 7, $0-8
+TEXT runtime·atomicload64(SB), NOSPLIT, $0-8
         MOVL    4(SP), BX
         MOVL    8(SP), AX
         // MOVQ (%EAX), %MM0
         BYTE $0x0f; BYTE $0x6f; BYTE $0x00
         // MOVQ %MM0, 0(%EBX)
         BYTE $0x0f; BYTE $0x7f; BYTE $0x03
         // EMMS
         BYTE $0x0F; BYTE $0x77
         RET
 
 // void runtime·atomicstore64(uint64 volatile* addr, uint64 v);
-TEXT runtime·atomicstore64(SB), 7, $0-12
+TEXT runtime·atomicstore64(SB), NOSPLIT, $0-12
         MOVL    4(SP), AX
         // MOVQ and EMMS were introduced on the Pentium MMX.
         // MOVQ 0x8(%ESP), %MM0
         BYTE $0x0f; BYTE $0x6f; BYTE $0x44; BYTE $0x24; BYTE $0x08
         // MOVQ %MM0, (%EAX)
         BYTE $0x0f; BYTE $0x7f; BYTE $0x00·
         // EMMS
         BYTE $0x0F; BYTE $0x77
         // This is essentially a no-op, but it provides required memory fencing.
         // It can be replaced with MFENCE, but MFENCE was introduced only on the Pentium4 (SSE2).
         MOVL    $0, AX
         LOCK
         XADDL   AX, (SP)
         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
+TEXT runtime·jmpdefer(SB), NOSPLIT, $0
         MOVL    4(SP), DX       // fn
         MOVL    8(SP), BX       // caller sp
         LEAL    -4(BX), SP      // caller sp after CALL
         SUBL    $5, (SP)        // return to CALL again
         MOVL    0(DX), BX
         JMP     BX      // but first run the deferred function
 
 // Save state of caller into g->sched.
-TEXT gosave<>(SB),7,$0
+TEXT gosave<>(SB),NOSPLIT,$0
         PUSHL   AX
         PUSHL   BX
         get_tls(BX)
         MOVL    g(BX), BX
         LEAL    arg+0(FP), AX
         MOVL    AX, (g_sched+gobuf_sp)(BX)
         MOVL    -4(AX), AX
         MOVL    AX, (g_sched+gobuf_pc)(BX)
         MOVL    $0, (g_sched+gobuf_ret)(BX)
         MOVL    $0, (g_sched+gobuf_ctxt)(BX)
         POPL    BX
         POPL    AX
         RET
 
 // asmcgocall(void(*fn)(void*), void *arg)
 // Call fn(arg) on the scheduler stack,
 // aligned appropriately for the gcc ABI.
 // See cgocall.c for more details.
-TEXT runtime·asmcgocall(SB),7,$0-8
+TEXT runtime·asmcgocall(SB),NOSPLIT,$0-8
         MOVL    fn+0(FP), AX
         MOVL    arg+4(FP), BX
         MOVL    SP, DX
 
         // Figure out if we need to switch to m->g0 stack.
         // We get called to create new OS threads too, and those
         // come in on the m->g0 stack already.
         get_tls(CX)
         MOVL    m(CX), BP
         MOVL    m_g0(BP), SI
@@ skipping 15 matching lines @@
         // Restore registers, g, stack pointer.
         get_tls(CX)
         MOVL    8(SP), DI
         MOVL    DI, g(CX)
         MOVL    4(SP), SP
         RET
 
 // cgocallback(void (*fn)(void*), void *frame, uintptr framesize)
 // Turn the fn into a Go func (by taking its address) and call
 // cgocallback_gofunc.
-TEXT runtime·cgocallback(SB),7,$12-12
+TEXT runtime·cgocallback(SB),NOSPLIT,$12-12
         LEAL    fn+0(FP), AX
         MOVL    AX, 0(SP)
         MOVL    frame+4(FP), AX
         MOVL    AX, 4(SP)
         MOVL    framesize+8(FP), AX
         MOVL    AX, 8(SP)
         MOVL    $runtime·cgocallback_gofunc(SB), AX
         CALL    AX
         RET
 
 // cgocallback_gofunc(FuncVal*, void *frame, uintptr framesize)
 // See cgocall.c for more details.
-TEXT runtime·cgocallback_gofunc(SB),7,$12-12
+TEXT runtime·cgocallback_gofunc(SB),NOSPLIT,$12-12
         // If m is nil, Go did not create the current thread.
         // Call needm to obtain one for temporary use.
         // In this case, we're running on the thread stack, so there's
         // lots of space, but the linker doesn't know. Hide the call from
         // the linker analysis by using an indirect call through AX.
         get_tls(CX)
 #ifdef GOOS_windows
         MOVL    $0, BP
         CMPL    CX, $0
         JEQ     2(PC)
@@ skipping 70 matching lines @@
         // for the duration of the call. Since the call is over, return it with dropm.
         CMPL    DX, $0
         JNE 3(PC)
         MOVL    $runtime·dropm(SB), AX
         CALL    AX
 
         // Done!
         RET
 
 // void setmg(M*, G*); set m and g. for use by needm.
-TEXT runtime·setmg(SB), 7, $0-8
+TEXT runtime·setmg(SB), NOSPLIT, $0-8
 #ifdef GOOS_windows
         MOVL    mm+0(FP), AX
         CMPL    AX, $0
         JNE     settls
         MOVL    $0, 0x14(FS)
         RET
 settls:
         LEAL    m_tls(AX), AX
         MOVL    AX, 0x14(FS)
 #endif
         MOVL    mm+0(FP), AX
         get_tls(CX)
         MOVL    mm+0(FP), AX
         MOVL    AX, m(CX)
         MOVL    gg+4(FP), BX
         MOVL    BX, g(CX)
         RET
 
 // void setmg_gcc(M*, G*); set m and g. for use by gcc
-TEXT setmg_gcc<>(SB), 7, $0
+TEXT setmg_gcc<>(SB), NOSPLIT, $0
         get_tls(AX)
         MOVL    mm+0(FP), DX
         MOVL    DX, m(AX)
         MOVL    gg+4(FP), DX
         MOVL    DX,g (AX)
         RET
 
 // check that SP is in range [g->stackbase, g->stackguard)
-TEXT runtime·stackcheck(SB), 7, $0-0
+TEXT runtime·stackcheck(SB), NOSPLIT, $0-0
         get_tls(CX)
         MOVL    g(CX), AX
         CMPL    g_stackbase(AX), SP
         JHI     2(PC)
         INT     $3
         CMPL    SP, g_stackguard(AX)
         JHI     2(PC)
         INT     $3
         RET
 
-TEXT runtime·memclr(SB),7,$0-8
+TEXT runtime·memclr(SB),NOSPLIT,$0-8
         MOVL    4(SP), DI               // arg 1 addr
         MOVL    8(SP), CX               // arg 2 count
         MOVL    CX, BX
         ANDL    $3, BX
         SHRL    $2, CX
         MOVL    $0, AX
         CLD
         REP
         STOSL
         MOVL    BX, CX
         REP
         STOSB
         RET
 
-TEXT runtime·getcallerpc(SB),7,$0-4
+TEXT runtime·getcallerpc(SB),NOSPLIT,$0-4
         MOVL    x+0(FP),AX              // addr of first arg
         MOVL    -4(AX),AX               // get calling pc
         RET
 
-TEXT runtime·setcallerpc(SB),7,$0-8
+TEXT runtime·setcallerpc(SB),NOSPLIT,$0-8
         MOVL    x+0(FP),AX              // addr of first arg
         MOVL    x+4(FP), BX
         MOVL    BX, -4(AX)              // set calling pc
         RET
 
-TEXT runtime·getcallersp(SB), 7, $0-4
+TEXT runtime·getcallersp(SB), NOSPLIT, $0-4
         MOVL    sp+0(FP), AX
         RET
 
 // int64 runtime·cputicks(void), so really
 // void runtime·cputicks(int64 *ticks)
-TEXT runtime·cputicks(SB),7,$0-4
+TEXT runtime·cputicks(SB),NOSPLIT,$0-4
         RDTSC
         MOVL    ret+0(FP), DI
         MOVL    AX, 0(DI)
         MOVL    DX, 4(DI)
         RET
 
-TEXT runtime·ldt0setup(SB),7,$16-0
+TEXT runtime·ldt0setup(SB),NOSPLIT,$16-0
         // set up ldt 7 to point at tls0
         // ldt 1 would be fine on Linux, but on OS X, 7 is as low as we can go.
         // the entry number is just a hint.  setldt will set up GS with what it used.
         MOVL    $7, 0(SP)
         LEAL    runtime·tls0(SB), AX
         MOVL    AX, 4(SP)
         MOVL    $32, 8(SP)      // sizeof(tls array)
         CALL    runtime·setldt(SB)
         RET
 
 TEXT runtime·emptyfunc(SB),0,$0-0
         RET
 
-TEXT runtime·abort(SB),7,$0-0
+TEXT runtime·abort(SB),NOSPLIT,$0-0
         INT $0x3
 
-TEXT runtime·stackguard(SB),7,$0-8
+TEXT runtime·stackguard(SB),NOSPLIT,$0-8
         MOVL    SP, DX
         MOVL    DX, sp+0(FP)
         get_tls(CX)
         MOVL    g(CX), BX
         MOVL    g_stackguard(BX), DX
         MOVL    DX, limit+4(FP)
         RET
 
 GLOBL runtime·tls0(SB), $32
 
 // hash function using AES hardware instructions
-TEXT runtime·aeshash(SB),7,$0-12
+TEXT runtime·aeshash(SB),NOSPLIT,$0-12
         MOVL    4(SP), DX       // ptr to hash value
         MOVL    8(SP), CX       // size
         MOVL    12(SP), AX      // ptr to data
         JMP     runtime·aeshashbody(SB)
 
-TEXT runtime·aeshashstr(SB),7,$0-12
+TEXT runtime·aeshashstr(SB),NOSPLIT,$0-12
         MOVL    4(SP), DX       // ptr to hash value
         MOVL    12(SP), AX      // ptr to string struct
         MOVL    4(AX), CX       // length of string
         MOVL    (AX), AX        // string data
         JMP     runtime·aeshashbody(SB)
 
 // AX: data
 // CX: length
 // DX: ptr to seed input / hash output
-TEXT runtime·aeshashbody(SB),7,$0-12
+TEXT runtime·aeshashbody(SB),NOSPLIT,$0-12
         MOVL    (DX), X0        // seed to low 32 bits of xmm0
         PINSRD  $1, CX, X0      // size to next 32 bits of xmm0
         MOVO    runtime·aeskeysched+0(SB), X2
         MOVO    runtime·aeskeysched+16(SB), X3
         CMPL    CX, $16
         JB      aessmall
 aesloop:
         CMPL    CX, $16
         JBE     aesloopend
         MOVOU   (AX), X1
@@ skipping 34 matching lines @@
         AESENC  X3, X0
         AESENC  X1, X0
 finalize:·······
         // finalize hash
         AESENC  X2, X0
         AESENC  X3, X0
         AESENC  X2, X0
         MOVL    X0, (DX)
         RET
 
-TEXT runtime·aeshash32(SB),7,$0-12
+TEXT runtime·aeshash32(SB),NOSPLIT,$0-12
         MOVL    4(SP), DX       // ptr to hash value
         MOVL    12(SP), AX      // ptr to data
         MOVL    (DX), X0        // seed
         PINSRD  $1, (AX), X0    // data
         AESENC  runtime·aeskeysched+0(SB), X0
         AESENC  runtime·aeskeysched+16(SB), X0
         AESENC  runtime·aeskeysched+0(SB), X0
         MOVL    X0, (DX)
         RET
 
-TEXT runtime·aeshash64(SB),7,$0-12
+TEXT runtime·aeshash64(SB),NOSPLIT,$0-12
         MOVL    4(SP), DX       // ptr to hash value
         MOVL    12(SP), AX      // ptr to data
         MOVQ    (AX), X0        // data
         PINSRD  $2, (DX), X0    // seed
         AESENC  runtime·aeskeysched+0(SB), X0
         AESENC  runtime·aeskeysched+16(SB), X0
         AESENC  runtime·aeskeysched+0(SB), X0
         MOVL    X0, (DX)
         RET
 
@@ skipping 71 matching lines @@
 DATA masks<>+0xe0(SB)/4, $0xffffffff
 DATA masks<>+0xe4(SB)/4, $0xffffffff
 DATA masks<>+0xe8(SB)/4, $0xffffffff
 DATA masks<>+0xec(SB)/4, $0x0000ffff
 ········
 DATA masks<>+0xf0(SB)/4, $0xffffffff
 DATA masks<>+0xf4(SB)/4, $0xffffffff
 DATA masks<>+0xf8(SB)/4, $0xffffffff
 DATA masks<>+0xfc(SB)/4, $0x00ffffff
 
-GLOBL masks<>(SB),8,$256
+GLOBL masks<>(SB),RODATA,$256
 
 // these are arguments to pshufb.  They move data down from
 // the high bytes of the register to the low bytes of the register.
 // index is how many bytes to move.
 DATA shifts<>+0x00(SB)/4, $0x00000000
 DATA shifts<>+0x04(SB)/4, $0x00000000
 DATA shifts<>+0x08(SB)/4, $0x00000000
 DATA shifts<>+0x0c(SB)/4, $0x00000000
 ········
 DATA shifts<>+0x10(SB)/4, $0xffffff0f
@@ skipping 64 matching lines @@
 DATA shifts<>+0xe0(SB)/4, $0x05040302
 DATA shifts<>+0xe4(SB)/4, $0x09080706
 DATA shifts<>+0xe8(SB)/4, $0x0d0c0b0a
 DATA shifts<>+0xec(SB)/4, $0xffff0f0e
 ········
 DATA shifts<>+0xf0(SB)/4, $0x04030201
 DATA shifts<>+0xf4(SB)/4, $0x08070605
 DATA shifts<>+0xf8(SB)/4, $0x0c0b0a09
 DATA shifts<>+0xfc(SB)/4, $0xff0f0e0d
 
-GLOBL shifts<>(SB),8,$256
-
-TEXT runtime·memeq(SB),7,$0-12
+GLOBL shifts<>(SB),RODATA,$256
+
+TEXT runtime·memeq(SB),NOSPLIT,$0-12
         MOVL    a+0(FP), SI
         MOVL    b+4(FP), DI
         MOVL    count+8(FP), BX
         JMP     runtime·memeqbody(SB)
 
-TEXT bytes·Equal(SB),7,$0-25
+TEXT bytes·Equal(SB),NOSPLIT,$0-25
         MOVL    a_len+4(FP), BX
         MOVL    b_len+16(FP), CX
         XORL    AX, AX
         CMPL    BX, CX
         JNE     eqret
         MOVL    a+0(FP), SI
         MOVL    b+12(FP), DI
         CALL    runtime·memeqbody(SB)
 eqret:
         MOVB    AX, ret+24(FP)
         RET
 
 // a in SI
 // b in DI
 // count in BX
-TEXT runtime·memeqbody(SB),7,$0-0
+TEXT runtime·memeqbody(SB),NOSPLIT,$0-0
         XORL    AX, AX
 
         CMPL    BX, $4
         JB      small
 
         // 64 bytes at a time using xmm registers
 hugeloop:
         CMPL    BX, $64
         JB      bigloop
         TESTL   $0x4000000, runtime·cpuid_edx(SB) // check for sse2
@@ skipping 72 matching lines @@
         MOVL    -4(DI)(BX*1), DI
         SHRL    CX, DI
 di_finish:
 
         SUBL    SI, DI
         SHLL    CX, DI
 equal:
         SETEQ   AX
         RET
 
-TEXT runtime·cmpstring(SB),7,$0-20
+TEXT runtime·cmpstring(SB),NOSPLIT,$0-20
         MOVL    s1+0(FP), SI
         MOVL    s1+4(FP), BX
         MOVL    s2+8(FP), DI
         MOVL    s2+12(FP), DX
         CALL    runtime·cmpbody(SB)
         MOVL    AX, res+16(FP)
         RET
 
-TEXT bytes·Compare(SB),7,$0-28
+TEXT bytes·Compare(SB),NOSPLIT,$0-28
         MOVL    s1+0(FP), SI
         MOVL    s1+4(FP), BX
         MOVL    s2+12(FP), DI
         MOVL    s2+16(FP), DX
         CALL    runtime·cmpbody(SB)
         MOVL    AX, res+24(FP)
         RET
 
-TEXT bytes·IndexByte(SB),7,$0
+TEXT bytes·IndexByte(SB),NOSPLIT,$0
         MOVL    s+0(FP), SI
         MOVL    s_len+4(FP), CX
         MOVB    c+12(FP), AL
         MOVL    SI, DI
         CLD; REPN; SCASB
         JZ 3(PC)
         MOVL    $-1, ret+16(FP)
         RET
         SUBL    SI, DI
         SUBL    $1, DI
         MOVL    DI, ret+16(FP)
         RET
 
-TEXT strings·IndexByte(SB),7,$0
+TEXT strings·IndexByte(SB),NOSPLIT,$0
         MOVL    s+0(FP), SI
         MOVL    s_len+4(FP), CX
         MOVB    c+8(FP), AL
         MOVL    SI, DI
         CLD; REPN; SCASB
         JZ 3(PC)
         MOVL    $-1, ret+12(FP)
         RET
         SUBL    SI, DI
         SUBL    $1, DI
         MOVL    DI, ret+12(FP)
         RET
 
 // input:
 //   SI = a
 //   DI = b
 //   BX = alen
 //   DX = blen
 // output:
 //   AX = 1/0/-1
-TEXT runtime·cmpbody(SB),7,$0-0
+TEXT runtime·cmpbody(SB),NOSPLIT,$0-0
         CMPL    SI, DI
         JEQ     cmp_allsame
         CMPL    BX, DX
         MOVL    DX, BP
         CMOVLLT BX, BP // BP = min(alen, blen)
         CMPL    BP, $4
         JB      cmp_small
         TESTL   $0x4000000, runtime·cpuid_edx(SB) // check for sse2
         JE      cmp_mediumloop
 cmp_largeloop:
@@ skipping 88 matching lines @@
         // all the bytes in common are the same, so we just need
         // to compare the lengths.
 cmp_allsame:
         XORL    AX, AX
         XORL    CX, CX
         CMPL    BX, DX
         SETGT   AX      // 1 if alen > blen
         SETEQ   CX      // 1 if alen == blen
         LEAL    -1(CX)(AX*2), AX        // 1,0,-1 result
         RET