← Back
Editing: 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 "go_asm.h" #include "go_tls.h" #include "funcdata.h" #include "textflag.h" // _rt0_386 is common startup code for most 386 systems when using // internal linking. This is the entry point for the program from the // kernel for an ordinary -buildmode=exe program. The stack holds the // number of arguments and the C-style argv. TEXT _rt0_386(SB),NOSPLIT,$8 MOVL 8(SP), AX // argc LEAL 12(SP), BX // argv MOVL AX, 0(SP) MOVL BX, 4(SP) JMP runtime·rt0_go(SB) // _rt0_386_lib is common startup code for most 386 systems when // using -buildmode=c-archive or -buildmode=c-shared. The linker will // arrange to invoke this function as a global constructor (for // c-archive) or when the shared library is loaded (for c-shared). // We expect argc and argv to be passed on the stack following the // usual C ABI. TEXT _rt0_386_lib(SB),NOSPLIT,$0 PUSHL BP MOVL SP, BP PUSHL BX PUSHL SI PUSHL DI MOVL 8(BP), AX MOVL AX, _rt0_386_lib_argc<>(SB) MOVL 12(BP), AX MOVL AX, _rt0_386_lib_argv<>(SB) // Synchronous initialization. CALL runtime·libpreinit(SB) SUBL $8, SP // Create a new thread to do the runtime initialization. MOVL _cgo_sys_thread_create(SB), AX TESTL AX, AX JZ nocgo // Align stack to call C function. // We moved SP to BP above, but BP was clobbered by the libpreinit call. MOVL SP, BP ANDL $~15, SP MOVL $_rt0_386_lib_go(SB), BX MOVL BX, 0(SP) MOVL $0, 4(SP) CALL AX MOVL BP, SP JMP restore nocgo: MOVL $0x800000, 0(SP) // stacksize = 8192KB MOVL $_rt0_386_lib_go(SB), AX MOVL AX, 4(SP) // fn CALL runtime·newosproc0(SB) restore: ADDL $8, SP POPL DI POPL SI POPL BX POPL BP RET // _rt0_386_lib_go initializes the Go runtime. // This is started in a separate thread by _rt0_386_lib. TEXT _rt0_386_lib_go(SB),NOSPLIT,$8 MOVL _rt0_386_lib_argc<>(SB), AX MOVL AX, 0(SP) MOVL _rt0_386_lib_argv<>(SB), AX MOVL AX, 4(SP) JMP runtime·rt0_go(SB) DATA _rt0_386_lib_argc<>(SB)/4, $0 GLOBL _rt0_386_lib_argc<>(SB),NOPTR, $4 DATA _rt0_386_lib_argv<>(SB)/4, $0 GLOBL _rt0_386_lib_argv<>(SB),NOPTR, $4 TEXT runtime·rt0_go(SB),NOSPLIT|NOFRAME|TOPFRAME,$0 // Copy arguments forward on an even stack. // Users of this function jump to it, they don't call it. MOVL 0(SP), AX MOVL 4(SP), 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. MOVL $runtime·g0(SB), BP LEAL (-64*1024+104)(SP), BX MOVL BX, g_stackguard0(BP) MOVL BX, g_stackguard1(BP) MOVL BX, (g_stack+stack_lo)(BP) MOVL SP, (g_stack+stack_hi)(BP) // find out information about the processor we're on // first see if CPUID instruction is supported. PUSHFL PUSHFL XORL $(1<<21), 0(SP) // flip ID bit POPFL PUSHFL POPL AX XORL 0(SP), AX POPFL // restore EFLAGS TESTL $(1<<21), AX JNE has_cpuid bad_proc: // show that the program requires MMX. MOVL $2, 0(SP) MOVL $bad_proc_msg<>(SB), 4(SP) MOVL $0x3d, 8(SP) CALL runtime·write(SB) MOVL $1, 0(SP) CALL runtime·exit(SB) CALL runtime·abort(SB) has_cpuid: MOVL $0, AX CPUID MOVL AX, SI CMPL AX, $0 JE nocpuinfo CMPL BX, $0x756E6547 // "Genu" JNE notintel CMPL DX, $0x49656E69 // "ineI" JNE notintel CMPL CX, $0x6C65746E // "ntel" JNE notintel MOVB $1, runtime·isIntel(SB) notintel: // Load EAX=1 cpuid flags MOVL $1, AX CPUID MOVL CX, DI // Move to global variable clobbers CX when generating PIC MOVL AX, runtime·processorVersionInfo(SB) // Check for MMX support TESTL $(1<<23), DX // MMX JZ bad_proc nocpuinfo: // if there is an _cgo_init, call it to let it // initialize and to set up GS. if not, // we set up GS ourselves. MOVL _cgo_init(SB), AX TESTL AX, AX JZ needtls #ifdef GOOS_android // arg 4: TLS base, stored in slot 0 (Android's TLS_SLOT_SELF). // Compensate for tls_g (+8). MOVL -8(TLS), BX MOVL BX, 12(SP) MOVL $runtime·tls_g(SB), 8(SP) // arg 3: &tls_g #else MOVL $0, BX MOVL BX, 12(SP) // arg 4: not used when using platform's TLS #ifdef GOOS_windows MOVL $runtime·tls_g(SB), 8(SP) // arg 3: &tls_g #else MOVL BX, 8(SP) // arg 3: not used when using platform's TLS #endif #endif MOVL $setg_gcc<>(SB), BX MOVL BX, 4(SP) // arg 2: setg_gcc MOVL BP, 0(SP) // arg 1: g0 CALL AX // update stackguard after _cgo_init MOVL $runtime·g0(SB), CX MOVL (g_stack+stack_lo)(CX), AX ADDL $const_stackGuard, AX MOVL AX, g_stackguard0(CX) MOVL AX, g_stackguard1(CX) #ifndef GOOS_windows // skip runtime·ldt0setup(SB) and tls test after _cgo_init for non-windows JMP ok #endif needtls: #ifdef GOOS_openbsd // skip runtime·ldt0setup(SB) and tls test on OpenBSD in all cases JMP ok #endif #ifdef GOOS_plan9 // skip runtime·ldt0setup(SB) and tls test on Plan 9 in all cases JMP ok #endif // set up %gs CALL ldt0setup<>(SB) // store through it, to make sure it works get_tls(BX) MOVL $0x123, g(BX) MOVL runtime·m0+m_tls(SB), AX CMPL AX, $0x123 JEQ ok MOVL AX, 0 // abort ok: // set up m and g "registers" get_tls(BX) LEAL runtime·g0(SB), DX MOVL DX, g(BX) LEAL runtime·m0(SB), AX // save m->g0 = g0 MOVL DX, m_g0(AX) // save g0->m = m0 MOVL AX, g_m(DX) CALL runtime·emptyfunc(SB) // fault if stack check is wrong // convention is D is always cleared CLD CALL runtime·check(SB) // saved argc, argv MOVL 120(SP), AX MOVL AX, 0(SP) MOVL 124(SP), AX MOVL AX, 4(SP) CALL runtime·args(SB) CALL runtime·osinit(SB) CALL runtime·schedinit(SB) // create a new goroutine to start program PUSHL $runtime·mainPC(SB) // entry CALL runtime·newproc(SB) POPL AX // start this M CALL runtime·mstart(SB) CALL runtime·abort(SB) RET DATA bad_proc_msg<>+0x00(SB)/61, $"This program can only be run on processors with MMX support.\n" GLOBL bad_proc_msg<>(SB), RODATA, $61 DATA runtime·mainPC+0(SB)/4,$runtime·main(SB) GLOBL runtime·mainPC(SB),RODATA,$4 TEXT runtime·breakpoint(SB),NOSPLIT,$0-0 INT $3 RET 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. FLDCW runtime·controlWord64(SB) RET TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0 CALL runtime·mstart0(SB) RET // not reached /* * go-routine */ // void gogo(Gobuf*) // restore state from Gobuf; longjmp TEXT runtime·gogo(SB), NOSPLIT, $0-4 MOVL buf+0(FP), BX // gobuf MOVL gobuf_g(BX), DX MOVL 0(DX), CX // make sure g != nil JMP gogo<>(SB) TEXT gogo<>(SB), NOSPLIT, $0 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 // func mcall(fn func(*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), NOSPLIT, $0-4 MOVL fn+0(FP), DI get_tls(DX) MOVL g(DX), AX // save state in g->sched MOVL 0(SP), BX // caller's PC MOVL BX, (g_sched+gobuf_pc)(AX) LEAL fn+0(FP), BX // caller's SP MOVL BX, (g_sched+gobuf_sp)(AX) // switch to m->g0 & its stack, call fn MOVL g(DX), BX MOVL g_m(BX), BX MOVL m_g0(BX), SI CMPL SI, AX // if g == m->g0 call badmcall JNE 3(PC) MOVL $runtime·badmcall(SB), AX JMP AX MOVL SI, g(DX) // g = m->g0 MOVL (g_sched+gobuf_sp)(SI), SP // sp = m->g0->sched.sp PUSHL AX MOVL DI, DX MOVL 0(DI), DI CALL DI POPL AX MOVL $runtime·badmcall2(SB), AX JMP AX RET // systemstack_switch is a dummy routine that systemstack leaves at the bottom // of the G stack. We need to distinguish the routine that // lives at the bottom of the G stack from the one that lives // at the top of the system stack because the one at the top of // the system stack terminates the stack walk (see topofstack()). TEXT runtime·systemstack_switch(SB), NOSPLIT, $0-0 RET // func systemstack(fn func()) TEXT runtime·systemstack(SB), NOSPLIT, $0-4 MOVL fn+0(FP), DI // DI = fn get_tls(CX) MOVL g(CX), AX // AX = g MOVL g_m(AX), BX // BX = m CMPL AX, m_gsignal(BX) JEQ noswitch MOVL m_g0(BX), DX // DX = g0 CMPL AX, DX JEQ noswitch CMPL AX, m_curg(BX) JNE bad // switch stacks // save our state in g->sched. Pretend to // be systemstack_switch if the G stack is scanned. CALL gosave_systemstack_switch<>(SB) // switch to g0 get_tls(CX) MOVL DX, g(CX) MOVL (g_sched+gobuf_sp)(DX), BX MOVL BX, SP // call target function MOVL DI, DX MOVL 0(DI), DI CALL DI // switch back to g get_tls(CX) MOVL g(CX), AX MOVL g_m(AX), BX MOVL m_curg(BX), AX MOVL AX, g(CX) MOVL (g_sched+gobuf_sp)(AX), SP MOVL $0, (g_sched+gobuf_sp)(AX) RET noswitch: // already on system stack; tail call the function // Using a tail call here cleans up tracebacks since we won't stop // at an intermediate systemstack. MOVL DI, DX MOVL 0(DI), DI JMP DI bad: // Bad: g is not gsignal, not g0, not curg. What is it? // Hide call from linker nosplit analysis. MOVL $runtime·badsystemstack(SB), AX CALL AX INT $3 // func switchToCrashStack0(fn func()) TEXT runtime·switchToCrashStack0(SB), NOSPLIT, $0-4 MOVL fn+0(FP), AX get_tls(CX) MOVL g(CX), BX // BX = g MOVL g_m(BX), DX // DX = curm // set g to gcrash LEAL runtime·gcrash(SB), BX // g = &gcrash MOVL DX, g_m(BX) // g.m = curm MOVL BX, m_g0(DX) // curm.g0 = g get_tls(CX) MOVL BX, g(CX) // switch to crashstack MOVL (g_stack+stack_hi)(BX), DX SUBL $(4*8), DX MOVL DX, SP // call target function MOVL AX, DX MOVL 0(AX), AX CALL AX // should never return CALL runtime·abort(SB) UNDEF /* * 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),NOSPLIT|NOFRAME,$0-0 // Cannot grow scheduler stack (m->g0). get_tls(CX) MOVL g(CX), DI MOVL g_m(DI), BX // Set g->sched to context in f. MOVL 0(SP), AX // f's PC MOVL AX, (g_sched+gobuf_pc)(DI) LEAL 4(SP), AX // f's SP MOVL AX, (g_sched+gobuf_sp)(DI) MOVL DX, (g_sched+gobuf_ctxt)(DI) MOVL m_g0(BX), SI CMPL g(CX), SI JNE 3(PC) CALL runtime·badmorestackg0(SB) CALL runtime·abort(SB) // Cannot grow signal stack. MOVL m_gsignal(BX), SI CMPL g(CX), SI JNE 3(PC) CALL runtime·badmorestackgsignal(SB) CALL runtime·abort(SB) // Called from f. // Set m->morebuf to f's caller. NOP SP // tell vet SP changed - stop checking offsets MOVL 4(SP), DI // f's caller's PC MOVL DI, (m_morebuf+gobuf_pc)(BX) LEAL 8(SP), CX // f's caller's SP MOVL CX, (m_morebuf+gobuf_sp)(BX) get_tls(CX) MOVL g(CX), SI MOVL SI, (m_morebuf+gobuf_g)(BX) // Call newstack on m->g0's stack. MOVL m_g0(BX), BP MOVL BP, g(CX) MOVL (g_sched+gobuf_sp)(BP), AX MOVL -4(AX), BX // fault if CALL would, before smashing SP MOVL AX, SP CALL runtime·newstack(SB) CALL runtime·abort(SB) // crash if newstack returns RET TEXT runtime·morestack_noctxt(SB),NOSPLIT,$0-0 MOVL $0, DX JMP runtime·morestack(SB) // reflectcall: call a function with the given argument list // func call(stackArgsType *_type, f *FuncVal, stackArgs *byte, stackArgsSize, stackRetOffset, frameSize uint32, regArgs *abi.RegArgs). // we don't have variable-sized frames, so we use a small number // 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 $NAME(SB), AX; \ JMP AX // Note: can't just "JMP NAME(SB)" - bad inlining results. TEXT ·reflectcall(SB), NOSPLIT, $0-28 MOVL frameSize+20(FP), CX DISPATCH(runtime·call16, 16) DISPATCH(runtime·call32, 32) DISPATCH(runtime·call64, 64) DISPATCH(runtime·call128, 128) DISPATCH(runtime·call256, 256) DISPATCH(runtime·call512, 512) DISPATCH(runtime·call1024, 1024) DISPATCH(runtime·call2048, 2048) DISPATCH(runtime·call4096, 4096) DISPATCH(runtime·call8192, 8192) DISPATCH(runtime·call16384, 16384) DISPATCH(runtime·call32768, 32768) DISPATCH(runtime·call65536, 65536) DISPATCH(runtime·call131072, 131072) DISPATCH(runtime·call262144, 262144) DISPATCH(runtime·call524288, 524288) DISPATCH(runtime·call1048576, 1048576) DISPATCH(runtime·call2097152, 2097152) DISPATCH(runtime·call4194304, 4194304) DISPATCH(runtime·call8388608, 8388608) DISPATCH(runtime·call16777216, 16777216) DISPATCH(runtime·call33554432, 33554432) DISPATCH(runtime·call67108864, 67108864) DISPATCH(runtime·call134217728, 134217728) DISPATCH(runtime·call268435456, 268435456) DISPATCH(runtime·call536870912, 536870912) DISPATCH(runtime·call1073741824, 1073741824) MOVL $runtime·badreflectcall(SB), AX JMP AX #define CALLFN(NAME,MAXSIZE) \ TEXT NAME(SB), WRAPPER, $MAXSIZE-28; \ NO_LOCAL_POINTERS; \ /* copy arguments to stack */ \ MOVL stackArgs+8(FP), SI; \ MOVL stackArgsSize+12(FP), CX; \ MOVL SP, DI; \ REP;MOVSB; \ /* call function */ \ MOVL f+4(FP), DX; \ MOVL (DX), AX; \ PCDATA $PCDATA_StackMapIndex, $0; \ CALL AX; \ /* copy return values back */ \ MOVL stackArgsType+0(FP), DX; \ MOVL stackArgs+8(FP), DI; \ MOVL stackArgsSize+12(FP), CX; \ MOVL stackRetOffset+16(FP), BX; \ MOVL SP, SI; \ ADDL BX, DI; \ ADDL BX, SI; \ SUBL BX, CX; \ CALL callRet<>(SB); \ RET // callRet copies return values back at the end of call*. This is a // separate function so it can allocate stack space for the arguments // to reflectcallmove. It does not follow the Go ABI; it expects its // arguments in registers. TEXT callRet<>(SB), NOSPLIT, $20-0 MOVL DX, 0(SP) MOVL DI, 4(SP) MOVL SI, 8(SP) MOVL CX, 12(SP) MOVL $0, 16(SP) CALL runtime·reflectcallmove(SB) RET CALLFN(·call16, 16) CALLFN(·call32, 32) CALLFN(·call64, 64) CALLFN(·call128, 128) CALLFN(·call256, 256) CALLFN(·call512, 512) CALLFN(·call1024, 1024) CALLFN(·call2048, 2048) CALLFN(·call4096, 4096) CALLFN(·call8192, 8192) CALLFN(·call16384, 16384) CALLFN(·call32768, 32768) CALLFN(·call65536, 65536) CALLFN(·call131072, 131072) CALLFN(·call262144, 262144) CALLFN(·call524288, 524288) CALLFN(·call1048576, 1048576) CALLFN(·call2097152, 2097152) CALLFN(·call4194304, 4194304) CALLFN(·call8388608, 8388608) CALLFN(·call16777216, 16777216) CALLFN(·call33554432, 33554432) CALLFN(·call67108864, 67108864) CALLFN(·call134217728, 134217728) CALLFN(·call268435456, 268435456) CALLFN(·call536870912, 536870912) CALLFN(·call1073741824, 1073741824) TEXT runtime·procyield(SB),NOSPLIT,$0-0 MOVL cycles+0(FP), AX again: PAUSE SUBL $1, AX JNZ again RET TEXT ·publicationBarrier(SB),NOSPLIT,$0-0 // Stores are already ordered on x86, so this is just a // compile barrier. RET // Save state of caller into g->sched, // but using fake PC from systemstack_switch. // Must only be called from functions with no locals ($0) // or else unwinding from systemstack_switch is incorrect. TEXT gosave_systemstack_switch<>(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 $runtime·systemstack_switch(SB), AX MOVL AX, (g_sched+gobuf_pc)(BX) MOVL $0, (g_sched+gobuf_ret)(BX) // Assert ctxt is zero. See func save. MOVL (g_sched+gobuf_ctxt)(BX), AX TESTL AX, AX JZ 2(PC) CALL runtime·abort(SB) POPL BX POPL AX RET // func asmcgocall_no_g(fn, arg unsafe.Pointer) // Call fn(arg) aligned appropriately for the gcc ABI. // Called on a system stack, and there may be no g yet (during needm). TEXT ·asmcgocall_no_g(SB),NOSPLIT,$0-8 MOVL fn+0(FP), AX MOVL arg+4(FP), BX MOVL SP, DX SUBL $32, SP ANDL $~15, SP // alignment, perhaps unnecessary MOVL DX, 8(SP) // save old SP MOVL BX, 0(SP) // first argument in x86-32 ABI CALL AX MOVL 8(SP), DX MOVL DX, SP RET // func asmcgocall(fn, arg unsafe.Pointer) int32 // Call fn(arg) on the scheduler stack, // aligned appropriately for the gcc ABI. // See cgocall.go for more details. TEXT ·asmcgocall(SB),NOSPLIT,$0-12 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. Or we might already // be on the m->gsignal stack. get_tls(CX) MOVL g(CX), DI CMPL DI, $0 JEQ nosave // Don't even have a G yet. MOVL g_m(DI), BP CMPL DI, m_gsignal(BP) JEQ noswitch MOVL m_g0(BP), SI CMPL DI, SI JEQ noswitch CALL gosave_systemstack_switch<>(SB) get_tls(CX) MOVL SI, g(CX) MOVL (g_sched+gobuf_sp)(SI), SP noswitch: // Now on a scheduling stack (a pthread-created stack). SUBL $32, SP ANDL $~15, SP // alignment, perhaps unnecessary MOVL DI, 8(SP) // save g MOVL (g_stack+stack_hi)(DI), DI SUBL DX, DI MOVL DI, 4(SP) // save depth in stack (can't just save SP, as stack might be copied during a callback) MOVL BX, 0(SP) // first argument in x86-32 ABI CALL AX // Restore registers, g, stack pointer. get_tls(CX) MOVL 8(SP), DI MOVL (g_stack+stack_hi)(DI), SI SUBL 4(SP), SI MOVL DI, g(CX) MOVL SI, SP MOVL AX, ret+8(FP) RET nosave: // Now on a scheduling stack (a pthread-created stack). SUBL $32, SP ANDL $~15, SP // alignment, perhaps unnecessary MOVL DX, 4(SP) // save original stack pointer MOVL BX, 0(SP) // first argument in x86-32 ABI CALL AX MOVL 4(SP), CX // restore original stack pointer MOVL CX, SP MOVL AX, ret+8(FP) RET // cgocallback(fn, frame unsafe.Pointer, ctxt uintptr) // See cgocall.go for more details. TEXT ·cgocallback(SB),NOSPLIT,$12-12 // Frame size must match commented places below NO_LOCAL_POINTERS // Skip cgocallbackg, just dropm when fn is nil, and frame is the saved g. // It is used to dropm while thread is exiting. MOVL fn+0(FP), AX CMPL AX, $0 JNE loadg // Restore the g from frame. get_tls(CX) MOVL frame+4(FP), BX MOVL BX, g(CX) JMP dropm loadg: // If g is nil, Go did not create the current thread, // or if this thread never called into Go on pthread platforms. // 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) // TODO #endif MOVL g(CX), BP CMPL BP, $0 JEQ needm MOVL g_m(BP), BP MOVL BP, savedm-4(SP) // saved copy of oldm JMP havem needm: MOVL $runtime·needAndBindM(SB), AX CALL AX MOVL $0, savedm-4(SP) get_tls(CX) MOVL g(CX), BP MOVL g_m(BP), BP // Set m->sched.sp = SP, so that if a panic happens // during the function we are about to execute, it will // have a valid SP to run on the g0 stack. // The next few lines (after the havem label) // will save this SP onto the stack and then write // the same SP back to m->sched.sp. That seems redundant, // but if an unrecovered panic happens, unwindm will // restore the g->sched.sp from the stack location // and then systemstack will try to use it. If we don't set it here, // that restored SP will be uninitialized (typically 0) and // will not be usable. MOVL m_g0(BP), SI MOVL SP, (g_sched+gobuf_sp)(SI) havem: // Now there's a valid m, and we're running on its m->g0. // Save current m->g0->sched.sp on stack and then set it to SP. // Save current sp in m->g0->sched.sp in preparation for // switch back to m->curg stack. // NOTE: unwindm knows that the saved g->sched.sp is at 0(SP). MOVL m_g0(BP), SI MOVL (g_sched+gobuf_sp)(SI), AX MOVL AX, 0(SP) MOVL SP, (g_sched+gobuf_sp)(SI) // Switch to m->curg stack and call runtime.cgocallbackg. // Because we are taking over the execution of m->curg // but *not* resuming what had been running, we need to // save that information (m->curg->sched) so we can restore it. // We can restore m->curg->sched.sp easily, because calling // runtime.cgocallbackg leaves SP unchanged upon return. // To save m->curg->sched.pc, we push it onto the curg stack and // open a frame the same size as cgocallback's g0 frame. // Once we switch to the curg stack, the pushed PC will appear // to be the return PC of cgocallback, so that the traceback // will seamlessly trace back into the earlier calls. MOVL m_curg(BP), SI MOVL SI, g(CX) MOVL (g_sched+gobuf_sp)(SI), DI // prepare stack as DI MOVL (g_sched+gobuf_pc)(SI), BP MOVL BP, -4(DI) // "push" return PC on the g stack // Gather our arguments into registers. MOVL fn+0(FP), AX MOVL frame+4(FP), BX MOVL ctxt+8(FP), CX LEAL -(4+12)(DI), SP // Must match declared frame size MOVL AX, 0(SP) MOVL BX, 4(SP) MOVL CX, 8(SP) CALL runtime·cgocallbackg(SB) // Restore g->sched (== m->curg->sched) from saved values. get_tls(CX) MOVL g(CX), SI MOVL 12(SP), BP // Must match declared frame size MOVL BP, (g_sched+gobuf_pc)(SI) LEAL (12+4)(SP), DI // Must match declared frame size MOVL DI, (g_sched+gobuf_sp)(SI) // Switch back to m->g0's stack and restore m->g0->sched.sp. // (Unlike m->curg, the g0 goroutine never uses sched.pc, // so we do not have to restore it.) MOVL g(CX), BP MOVL g_m(BP), BP MOVL m_g0(BP), SI MOVL SI, g(CX) MOVL (g_sched+gobuf_sp)(SI), SP MOVL 0(SP), AX MOVL AX, (g_sched+gobuf_sp)(SI) // If the m on entry was nil, we called needm above to borrow an m, // 1. for the duration of the call on non-pthread platforms, // 2. or the duration of the C thread alive on pthread platforms. // If the m on entry wasn't nil, // 1. the thread might be a Go thread, // 2. or it wasn't the first call from a C thread on pthread platforms, // since then we skip dropm to reuse the m in the first call. MOVL savedm-4(SP), DX CMPL DX, $0 JNE droppedm // Skip dropm to reuse it in the next call, when a pthread key has been created. MOVL _cgo_pthread_key_created(SB), DX // It means cgo is disabled when _cgo_pthread_key_created is a nil pointer, need dropm. CMPL DX, $0 JEQ dropm CMPL (DX), $0 JNE droppedm dropm: MOVL $runtime·dropm(SB), AX CALL AX droppedm: // Done! RET // void setg(G*); set g. for use by needm. TEXT runtime·setg(SB), NOSPLIT, $0-4 MOVL gg+0(FP), BX #ifdef GOOS_windows MOVL runtime·tls_g(SB), CX CMPL BX, $0 JNE settls MOVL $0, 0(CX)(FS) RET settls: MOVL g_m(BX), AX LEAL m_tls(AX), AX MOVL AX, 0(CX)(FS) #endif get_tls(CX) MOVL BX, g(CX) RET // void setg_gcc(G*); set g. for use by gcc TEXT setg_gcc<>(SB), NOSPLIT, $0 get_tls(AX) MOVL gg+0(FP), DX MOVL DX, g(AX) RET TEXT runtime·abort(SB),NOSPLIT,$0-0 INT $3 loop: JMP loop // check that SP is in range [g->stack.lo, g->stack.hi) TEXT runtime·stackcheck(SB), NOSPLIT, $0-0 get_tls(CX) MOVL g(CX), AX CMPL (g_stack+stack_hi)(AX), SP JHI 2(PC) CALL runtime·abort(SB) CMPL SP, (g_stack+stack_lo)(AX) JHI 2(PC) CALL runtime·abort(SB) RET // func cputicks() int64 TEXT runtime·cputicks(SB),NOSPLIT,$0-8 // LFENCE/MFENCE instruction support is dependent on SSE2. // When no SSE2 support is present do not enforce any serialization // since using CPUID to serialize the instruction stream is // very costly. #ifdef GO386_softfloat JMP rdtsc // no fence instructions available #endif CMPB internal∕cpu·X86+const_offsetX86HasRDTSCP(SB), $1 JNE fences // Instruction stream serializing RDTSCP is supported. // RDTSCP is supported by Intel Nehalem (2008) and // AMD K8 Rev. F (2006) and newer. RDTSCP done: MOVL AX, ret_lo+0(FP) MOVL DX, ret_hi+4(FP) RET fences: // MFENCE is instruction stream serializing and flushes the // store buffers on AMD. The serialization semantics of LFENCE on AMD // are dependent on MSR C001_1029 and CPU generation. // LFENCE on Intel does wait for all previous instructions to have executed. // Intel recommends MFENCE;LFENCE in its manuals before RDTSC to have all // previous instructions executed and all previous loads and stores to globally visible. // Using MFENCE;LFENCE here aligns the serializing properties without // runtime detection of CPU manufacturer. MFENCE LFENCE rdtsc: RDTSC JMP done TEXT ldt0setup<>(SB),NOSPLIT,$16-0 #ifdef GOOS_windows CALL runtime·wintls(SB) #endif // set up ldt 7 to point at m0.tls // 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·m0+m_tls(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 // hash function using AES hardware instructions TEXT runtime·memhash(SB),NOSPLIT,$0-16 CMPB runtime·useAeshash(SB), $0 JEQ noaes MOVL p+0(FP), AX // ptr to data MOVL s+8(FP), BX // size LEAL ret+12(FP), DX JMP aeshashbody<>(SB) noaes: JMP runtime·memhashFallback(SB) TEXT runtime·strhash(SB),NOSPLIT,$0-12 CMPB runtime·useAeshash(SB), $0 JEQ noaes MOVL p+0(FP), AX // ptr to string object MOVL 4(AX), BX // length of string MOVL (AX), AX // string data LEAL ret+8(FP), DX JMP aeshashbody<>(SB) noaes: JMP runtime·strhashFallback(SB) // AX: data // BX: length // DX: address to put return value TEXT aeshashbody<>(SB),NOSPLIT,$0-0 MOVL h+4(FP), X0 // 32 bits of per-table hash seed PINSRW $4, BX, X0 // 16 bits of length PSHUFHW $0, X0, X0 // replace size with its low 2 bytes repeated 4 times MOVO X0, X1 // save unscrambled seed PXOR runtime·aeskeysched(SB), X0 // xor in per-process seed AESENC X0, X0 // scramble seed CMPL BX, $16 JB aes0to15 JE aes16 CMPL BX, $32 JBE aes17to32 CMPL BX, $64 JBE aes33to64 JMP aes65plus aes0to15: TESTL BX, BX JE aes0 ADDL $16, AX TESTW $0xff0, AX JE endofpage // 16 bytes loaded at this address won't cross // a page boundary, so we can load it directly. MOVOU -16(AX), X1 ADDL BX, BX PAND masks<>(SB)(BX*8), X1 final1: PXOR X0, X1 // xor data with seed AESENC X1, X1 // scramble combo 3 times AESENC X1, X1 AESENC X1, X1 MOVL X1, (DX) RET endofpage: // address ends in 1111xxxx. Might be up against // a page boundary, so load ending at last byte. // Then shift bytes down using pshufb. MOVOU -32(AX)(BX*1), X1 ADDL BX, BX PSHUFB shifts<>(SB)(BX*8), X1 JMP final1 aes0: // Return scrambled input seed AESENC X0, X0 MOVL X0, (DX) RET aes16: MOVOU (AX), X1 JMP final1 aes17to32: // make second starting seed PXOR runtime·aeskeysched+16(SB), X1 AESENC X1, X1 // load data to be hashed MOVOU (AX), X2 MOVOU -16(AX)(BX*1), X3 // xor with seed PXOR X0, X2 PXOR X1, X3 // scramble 3 times AESENC X2, X2 AESENC X3, X3 AESENC X2, X2 AESENC X3, X3 AESENC X2, X2 AESENC X3, X3 // combine results PXOR X3, X2 MOVL X2, (DX) RET aes33to64: // make 3 more starting seeds MOVO X1, X2 MOVO X1, X3 PXOR runtime·aeskeysched+16(SB), X1 PXOR runtime·aeskeysched+32(SB), X2 PXOR runtime·aeskeysched+48(SB), X3 AESENC X1, X1 AESENC X2, X2 AESENC X3, X3 MOVOU (AX), X4 MOVOU 16(AX), X5 MOVOU -32(AX)(BX*1), X6 MOVOU -16(AX)(BX*1), X7 PXOR X0, X4 PXOR X1, X5 PXOR X2, X6 PXOR X3, X7 AESENC X4, X4 AESENC X5, X5 AESENC X6, X6 AESENC X7, X7 AESENC X4, X4 AESENC X5, X5 AESENC X6, X6 AESENC X7, X7 AESENC X4, X4 AESENC X5, X5 AESENC X6, X6 AESENC X7, X7 PXOR X6, X4 PXOR X7, X5 PXOR X5, X4 MOVL X4, (DX) RET aes65plus: // make 3 more starting seeds MOVO X1, X2 MOVO X1, X3 PXOR runtime·aeskeysched+16(SB), X1 PXOR runtime·aeskeysched+32(SB), X2 PXOR runtime·aeskeysched+48(SB), X3 AESENC X1, X1 AESENC X2, X2 AESENC X3, X3 // start with last (possibly overlapping) block MOVOU -64(AX)(BX*1), X4 MOVOU -48(AX)(BX*1), X5 MOVOU -32(AX)(BX*1), X6 MOVOU -16(AX)(BX*1), X7 // scramble state once AESENC X0, X4 AESENC X1, X5 AESENC X2, X6 AESENC X3, X7 // compute number of remaining 64-byte blocks DECL BX SHRL $6, BX aesloop: // scramble state, xor in a block MOVOU (AX), X0 MOVOU 16(AX), X1 MOVOU 32(AX), X2 MOVOU 48(AX), X3 AESENC X0, X4 AESENC X1, X5 AESENC X2, X6 AESENC X3, X7 // scramble state AESENC X4, X4 AESENC X5, X5 AESENC X6, X6 AESENC X7, X7 ADDL $64, AX DECL BX JNE aesloop // 3 more scrambles to finish AESENC X4, X4 AESENC X5, X5 AESENC X6, X6 AESENC X7, X7 AESENC X4, X4 AESENC X5, X5 AESENC X6, X6 AESENC X7, X7 AESENC X4, X4 AESENC X5, X5 AESENC X6, X6 AESENC X7, X7 PXOR X6, X4 PXOR X7, X5 PXOR X5, X4 MOVL X4, (DX) RET TEXT runtime·memhash32(SB),NOSPLIT,$0-12 CMPB runtime·useAeshash(SB), $0 JEQ noaes MOVL p+0(FP), AX // ptr to data MOVL h+4(FP), X0 // seed PINSRD $1, (AX), X0 // data AESENC runtime·aeskeysched+0(SB), X0 AESENC runtime·aeskeysched+16(SB), X0 AESENC runtime·aeskeysched+32(SB), X0 MOVL X0, ret+8(FP) RET noaes: JMP runtime·memhash32Fallback(SB) TEXT runtime·memhash64(SB),NOSPLIT,$0-12 CMPB runtime·useAeshash(SB), $0 JEQ noaes MOVL p+0(FP), AX // ptr to data MOVQ (AX), X0 // data PINSRD $2, h+4(FP), X0 // seed AESENC runtime·aeskeysched+0(SB), X0 AESENC runtime·aeskeysched+16(SB), X0 AESENC runtime·aeskeysched+32(SB), X0 MOVL X0, ret+8(FP) RET noaes: JMP runtime·memhash64Fallback(SB) // simple mask to get rid of data in the high part of the register. DATA masks<>+0x00(SB)/4, $0x00000000 DATA masks<>+0x04(SB)/4, $0x00000000 DATA masks<>+0x08(SB)/4, $0x00000000 DATA masks<>+0x0c(SB)/4, $0x00000000 DATA masks<>+0x10(SB)/4, $0x000000ff DATA masks<>+0x14(SB)/4, $0x00000000 DATA masks<>+0x18(SB)/4, $0x00000000 DATA masks<>+0x1c(SB)/4, $0x00000000 DATA masks<>+0x20(SB)/4, $0x0000ffff DATA masks<>+0x24(SB)/4, $0x00000000 DATA masks<>+0x28(SB)/4, $0x00000000 DATA masks<>+0x2c(SB)/4, $0x00000000 DATA masks<>+0x30(SB)/4, $0x00ffffff DATA masks<>+0x34(SB)/4, $0x00000000 DATA masks<>+0x38(SB)/4, $0x00000000 DATA masks<>+0x3c(SB)/4, $0x00000000 DATA masks<>+0x40(SB)/4, $0xffffffff DATA masks<>+0x44(SB)/4, $0x00000000 DATA masks<>+0x48(SB)/4, $0x00000000 DATA masks<>+0x4c(SB)/4, $0x00000000 DATA masks<>+0x50(SB)/4, $0xffffffff DATA masks<>+0x54(SB)/4, $0x000000ff DATA masks<>+0x58(SB)/4, $0x00000000 DATA masks<>+0x5c(SB)/4, $0x00000000 DATA masks<>+0x60(SB)/4, $0xffffffff DATA masks<>+0x64(SB)/4, $0x0000ffff DATA masks<>+0x68(SB)/4, $0x00000000 DATA masks<>+0x6c(SB)/4, $0x00000000 DATA masks<>+0x70(SB)/4, $0xffffffff DATA masks<>+0x74(SB)/4, $0x00ffffff DATA masks<>+0x78(SB)/4, $0x00000000 DATA masks<>+0x7c(SB)/4, $0x00000000 DATA masks<>+0x80(SB)/4, $0xffffffff DATA masks<>+0x84(SB)/4, $0xffffffff DATA masks<>+0x88(SB)/4, $0x00000000 DATA masks<>+0x8c(SB)/4, $0x00000000 DATA masks<>+0x90(SB)/4, $0xffffffff DATA masks<>+0x94(SB)/4, $0xffffffff DATA masks<>+0x98(SB)/4, $0x000000ff DATA masks<>+0x9c(SB)/4, $0x00000000 DATA masks<>+0xa0(SB)/4, $0xffffffff DATA masks<>+0xa4(SB)/4, $0xffffffff DATA masks<>+0xa8(SB)/4, $0x0000ffff DATA masks<>+0xac(SB)/4, $0x00000000 DATA masks<>+0xb0(SB)/4, $0xffffffff DATA masks<>+0xb4(SB)/4, $0xffffffff DATA masks<>+0xb8(SB)/4, $0x00ffffff DATA masks<>+0xbc(SB)/4, $0x00000000 DATA masks<>+0xc0(SB)/4, $0xffffffff DATA masks<>+0xc4(SB)/4, $0xffffffff DATA masks<>+0xc8(SB)/4, $0xffffffff DATA masks<>+0xcc(SB)/4, $0x00000000 DATA masks<>+0xd0(SB)/4, $0xffffffff DATA masks<>+0xd4(SB)/4, $0xffffffff DATA masks<>+0xd8(SB)/4, $0xffffffff DATA masks<>+0xdc(SB)/4, $0x000000ff 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),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 DATA shifts<>+0x14(SB)/4, $0xffffffff DATA shifts<>+0x18(SB)/4, $0xffffffff DATA shifts<>+0x1c(SB)/4, $0xffffffff DATA shifts<>+0x20(SB)/4, $0xffff0f0e DATA shifts<>+0x24(SB)/4, $0xffffffff DATA shifts<>+0x28(SB)/4, $0xffffffff DATA shifts<>+0x2c(SB)/4, $0xffffffff DATA shifts<>+0x30(SB)/4, $0xff0f0e0d DATA shifts<>+0x34(SB)/4, $0xffffffff DATA shifts<>+0x38(SB)/4, $0xffffffff DATA shifts<>+0x3c(SB)/4, $0xffffffff DATA shifts<>+0x40(SB)/4, $0x0f0e0d0c DATA shifts<>+0x44(SB)/4, $0xffffffff DATA shifts<>+0x48(SB)/4, $0xffffffff DATA shifts<>+0x4c(SB)/4, $0xffffffff DATA shifts<>+0x50(SB)/4, $0x0e0d0c0b DATA shifts<>+0x54(SB)/4, $0xffffff0f DATA shifts<>+0x58(SB)/4, $0xffffffff DATA shifts<>+0x5c(SB)/4, $0xffffffff DATA shifts<>+0x60(SB)/4, $0x0d0c0b0a DATA shifts<>+0x64(SB)/4, $0xffff0f0e DATA shifts<>+0x68(SB)/4, $0xffffffff DATA shifts<>+0x6c(SB)/4, $0xffffffff DATA shifts<>+0x70(SB)/4, $0x0c0b0a09 DATA shifts<>+0x74(SB)/4, $0xff0f0e0d DATA shifts<>+0x78(SB)/4, $0xffffffff DATA shifts<>+0x7c(SB)/4, $0xffffffff DATA shifts<>+0x80(SB)/4, $0x0b0a0908 DATA shifts<>+0x84(SB)/4, $0x0f0e0d0c DATA shifts<>+0x88(SB)/4, $0xffffffff DATA shifts<>+0x8c(SB)/4, $0xffffffff DATA shifts<>+0x90(SB)/4, $0x0a090807 DATA shifts<>+0x94(SB)/4, $0x0e0d0c0b DATA shifts<>+0x98(SB)/4, $0xffffff0f DATA shifts<>+0x9c(SB)/4, $0xffffffff DATA shifts<>+0xa0(SB)/4, $0x09080706 DATA shifts<>+0xa4(SB)/4, $0x0d0c0b0a DATA shifts<>+0xa8(SB)/4, $0xffff0f0e DATA shifts<>+0xac(SB)/4, $0xffffffff DATA shifts<>+0xb0(SB)/4, $0x08070605 DATA shifts<>+0xb4(SB)/4, $0x0c0b0a09 DATA shifts<>+0xb8(SB)/4, $0xff0f0e0d DATA shifts<>+0xbc(SB)/4, $0xffffffff DATA shifts<>+0xc0(SB)/4, $0x07060504 DATA shifts<>+0xc4(SB)/4, $0x0b0a0908 DATA shifts<>+0xc8(SB)/4, $0x0f0e0d0c DATA shifts<>+0xcc(SB)/4, $0xffffffff DATA shifts<>+0xd0(SB)/4, $0x06050403 DATA shifts<>+0xd4(SB)/4, $0x0a090807 DATA shifts<>+0xd8(SB)/4, $0x0e0d0c0b DATA shifts<>+0xdc(SB)/4, $0xffffff0f 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),RODATA,$256 TEXT ·checkASM(SB),NOSPLIT,$0-1 // check that masks<>(SB) and shifts<>(SB) are aligned to 16-byte MOVL $masks<>(SB), AX MOVL $shifts<>(SB), BX ORL BX, AX TESTL $15, AX SETEQ ret+0(FP) RET TEXT runtime·return0(SB), NOSPLIT, $0 MOVL $0, AX RET // Called from cgo wrappers, this function returns g->m->curg.stack.hi. // Must obey the gcc calling convention. TEXT _cgo_topofstack(SB),NOSPLIT,$0 get_tls(CX) MOVL g(CX), AX MOVL g_m(AX), AX MOVL m_curg(AX), AX MOVL (g_stack+stack_hi)(AX), AX RET // The top-most function running on a goroutine // returns to goexit+PCQuantum. TEXT runtime·goexit(SB),NOSPLIT|TOPFRAME,$0-0 BYTE $0x90 // NOP CALL runtime·goexit1(SB) // does not return // traceback from goexit1 must hit code range of goexit BYTE $0x90 // NOP // Add a module's moduledata to the linked list of moduledata objects. This // is called from .init_array by a function generated in the linker and so // follows the platform ABI wrt register preservation -- it only touches AX, // CX (implicitly) and DX, but it does not follow the ABI wrt arguments: // instead the pointer to the moduledata is passed in AX. TEXT runtime·addmoduledata(SB),NOSPLIT,$0-0 MOVL runtime·lastmoduledatap(SB), DX MOVL AX, moduledata_next(DX) MOVL AX, runtime·lastmoduledatap(SB) RET TEXT runtime·uint32tofloat64(SB),NOSPLIT,$8-12 MOVL a+0(FP), AX MOVL AX, 0(SP) MOVL $0, 4(SP) FMOVV 0(SP), F0 FMOVDP F0, ret+4(FP) RET TEXT runtime·float64touint32(SB),NOSPLIT,$12-12 FMOVD a+0(FP), F0 FSTCW 0(SP) FLDCW runtime·controlWord64trunc(SB) FMOVVP F0, 4(SP) FLDCW 0(SP) MOVL 4(SP), AX MOVL AX, ret+8(FP) RET // gcWriteBarrier informs the GC about heap pointer writes. // // gcWriteBarrier returns space in a write barrier buffer which // should be filled in by the caller. // gcWriteBarrier does NOT follow the Go ABI. It accepts the // number of bytes of buffer needed in DI, and returns a pointer // to the buffer space in DI. // It clobbers FLAGS. It does not clobber any general-purpose registers, // but may clobber others (e.g., SSE registers). // Typical use would be, when doing *(CX+88) = AX // CMPL $0, runtime.writeBarrier(SB) // JEQ dowrite // CALL runtime.gcBatchBarrier2(SB) // MOVL AX, (DI) // MOVL 88(CX), DX // MOVL DX, 4(DI) // dowrite: // MOVL AX, 88(CX) TEXT gcWriteBarrier<>(SB),NOSPLIT,$28 // Save the registers clobbered by the fast path. This is slightly // faster than having the caller spill these. MOVL CX, 20(SP) MOVL BX, 24(SP) retry: // TODO: Consider passing g.m.p in as an argument so they can be shared // across a sequence of write barriers. get_tls(BX) MOVL g(BX), BX MOVL g_m(BX), BX MOVL m_p(BX), BX // Get current buffer write position. MOVL (p_wbBuf+wbBuf_next)(BX), CX // original next position ADDL DI, CX // new next position // Is the buffer full? CMPL CX, (p_wbBuf+wbBuf_end)(BX) JA flush // Commit to the larger buffer. MOVL CX, (p_wbBuf+wbBuf_next)(BX) // Make return value (the original next position) SUBL DI, CX MOVL CX, DI // Restore registers. MOVL 20(SP), CX MOVL 24(SP), BX RET flush: // Save all general purpose registers since these could be // clobbered by wbBufFlush and were not saved by the caller. MOVL DI, 0(SP) MOVL AX, 4(SP) // BX already saved // CX already saved MOVL DX, 8(SP) MOVL BP, 12(SP) MOVL SI, 16(SP) // DI already saved CALL runtime·wbBufFlush(SB) MOVL 0(SP), DI MOVL 4(SP), AX MOVL 8(SP), DX MOVL 12(SP), BP MOVL 16(SP), SI JMP retry TEXT runtime·gcWriteBarrier1<ABIInternal>(SB),NOSPLIT,$0 MOVL $4, DI JMP gcWriteBarrier<>(SB) TEXT runtime·gcWriteBarrier2<ABIInternal>(SB),NOSPLIT,$0 MOVL $8, DI JMP gcWriteBarrier<>(SB) TEXT runtime·gcWriteBarrier3<ABIInternal>(SB),NOSPLIT,$0 MOVL $12, DI JMP gcWriteBarrier<>(SB) TEXT runtime·gcWriteBarrier4<ABIInternal>(SB),NOSPLIT,$0 MOVL $16, DI JMP gcWriteBarrier<>(SB) TEXT runtime·gcWriteBarrier5<ABIInternal>(SB),NOSPLIT,$0 MOVL $20, DI JMP gcWriteBarrier<>(SB) TEXT runtime·gcWriteBarrier6<ABIInternal>(SB),NOSPLIT,$0 MOVL $24, DI JMP gcWriteBarrier<>(SB) TEXT runtime·gcWriteBarrier7<ABIInternal>(SB),NOSPLIT,$0 MOVL $28, DI JMP gcWriteBarrier<>(SB) TEXT runtime·gcWriteBarrier8<ABIInternal>(SB),NOSPLIT,$0 MOVL $32, DI JMP gcWriteBarrier<>(SB) // Note: these functions use a special calling convention to save generated code space. // Arguments are passed in registers, but the space for those arguments are allocated // in the caller's stack frame. These stubs write the args into that stack space and // then tail call to the corresponding runtime handler. // The tail call makes these stubs disappear in backtraces. TEXT runtime·panicIndex(SB),NOSPLIT,$0-8 MOVL AX, x+0(FP) MOVL CX, y+4(FP) JMP runtime·goPanicIndex(SB) TEXT runtime·panicIndexU(SB),NOSPLIT,$0-8 MOVL AX, x+0(FP) MOVL CX, y+4(FP) JMP runtime·goPanicIndexU(SB) TEXT runtime·panicSliceAlen(SB),NOSPLIT,$0-8 MOVL CX, x+0(FP) MOVL DX, y+4(FP) JMP runtime·goPanicSliceAlen(SB) TEXT runtime·panicSliceAlenU(SB),NOSPLIT,$0-8 MOVL CX, x+0(FP) MOVL DX, y+4(FP) JMP runtime·goPanicSliceAlenU(SB) TEXT runtime·panicSliceAcap(SB),NOSPLIT,$0-8 MOVL CX, x+0(FP) MOVL DX, y+4(FP) JMP runtime·goPanicSliceAcap(SB) TEXT runtime·panicSliceAcapU(SB),NOSPLIT,$0-8 MOVL CX, x+0(FP) MOVL DX, y+4(FP) JMP runtime·goPanicSliceAcapU(SB) TEXT runtime·panicSliceB(SB),NOSPLIT,$0-8 MOVL AX, x+0(FP) MOVL CX, y+4(FP) JMP runtime·goPanicSliceB(SB) TEXT runtime·panicSliceBU(SB),NOSPLIT,$0-8 MOVL AX, x+0(FP) MOVL CX, y+4(FP) JMP runtime·goPanicSliceBU(SB) TEXT runtime·panicSlice3Alen(SB),NOSPLIT,$0-8 MOVL DX, x+0(FP) MOVL BX, y+4(FP) JMP runtime·goPanicSlice3Alen(SB) TEXT runtime·panicSlice3AlenU(SB),NOSPLIT,$0-8 MOVL DX, x+0(FP) MOVL BX, y+4(FP) JMP runtime·goPanicSlice3AlenU(SB) TEXT runtime·panicSlice3Acap(SB),NOSPLIT,$0-8 MOVL DX, x+0(FP) MOVL BX, y+4(FP) JMP runtime·goPanicSlice3Acap(SB) TEXT runtime·panicSlice3AcapU(SB),NOSPLIT,$0-8 MOVL DX, x+0(FP) MOVL BX, y+4(FP) JMP runtime·goPanicSlice3AcapU(SB) TEXT runtime·panicSlice3B(SB),NOSPLIT,$0-8 MOVL CX, x+0(FP) MOVL DX, y+4(FP) JMP runtime·goPanicSlice3B(SB) TEXT runtime·panicSlice3BU(SB),NOSPLIT,$0-8 MOVL CX, x+0(FP) MOVL DX, y+4(FP) JMP runtime·goPanicSlice3BU(SB) TEXT runtime·panicSlice3C(SB),NOSPLIT,$0-8 MOVL AX, x+0(FP) MOVL CX, y+4(FP) JMP runtime·goPanicSlice3C(SB) TEXT runtime·panicSlice3CU(SB),NOSPLIT,$0-8 MOVL AX, x+0(FP) MOVL CX, y+4(FP) JMP runtime·goPanicSlice3CU(SB) TEXT runtime·panicSliceConvert(SB),NOSPLIT,$0-8 MOVL DX, x+0(FP) MOVL BX, y+4(FP) JMP runtime·goPanicSliceConvert(SB) // Extended versions for 64-bit indexes. TEXT runtime·panicExtendIndex(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL AX, lo+4(FP) MOVL CX, y+8(FP) JMP runtime·goPanicExtendIndex(SB) TEXT runtime·panicExtendIndexU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL AX, lo+4(FP) MOVL CX, y+8(FP) JMP runtime·goPanicExtendIndexU(SB) TEXT runtime·panicExtendSliceAlen(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL CX, lo+4(FP) MOVL DX, y+8(FP) JMP runtime·goPanicExtendSliceAlen(SB) TEXT runtime·panicExtendSliceAlenU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL CX, lo+4(FP) MOVL DX, y+8(FP) JMP runtime·goPanicExtendSliceAlenU(SB) TEXT runtime·panicExtendSliceAcap(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL CX, lo+4(FP) MOVL DX, y+8(FP) JMP runtime·goPanicExtendSliceAcap(SB) TEXT runtime·panicExtendSliceAcapU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL CX, lo+4(FP) MOVL DX, y+8(FP) JMP runtime·goPanicExtendSliceAcapU(SB) TEXT runtime·panicExtendSliceB(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL AX, lo+4(FP) MOVL CX, y+8(FP) JMP runtime·goPanicExtendSliceB(SB) TEXT runtime·panicExtendSliceBU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL AX, lo+4(FP) MOVL CX, y+8(FP) JMP runtime·goPanicExtendSliceBU(SB) TEXT runtime·panicExtendSlice3Alen(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL DX, lo+4(FP) MOVL BX, y+8(FP) JMP runtime·goPanicExtendSlice3Alen(SB) TEXT runtime·panicExtendSlice3AlenU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL DX, lo+4(FP) MOVL BX, y+8(FP) JMP runtime·goPanicExtendSlice3AlenU(SB) TEXT runtime·panicExtendSlice3Acap(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL DX, lo+4(FP) MOVL BX, y+8(FP) JMP runtime·goPanicExtendSlice3Acap(SB) TEXT runtime·panicExtendSlice3AcapU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL DX, lo+4(FP) MOVL BX, y+8(FP) JMP runtime·goPanicExtendSlice3AcapU(SB) TEXT runtime·panicExtendSlice3B(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL CX, lo+4(FP) MOVL DX, y+8(FP) JMP runtime·goPanicExtendSlice3B(SB) TEXT runtime·panicExtendSlice3BU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL CX, lo+4(FP) MOVL DX, y+8(FP) JMP runtime·goPanicExtendSlice3BU(SB) TEXT runtime·panicExtendSlice3C(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL AX, lo+4(FP) MOVL CX, y+8(FP) JMP runtime·goPanicExtendSlice3C(SB) TEXT runtime·panicExtendSlice3CU(SB),NOSPLIT,$0-12 MOVL SI, hi+0(FP) MOVL AX, lo+4(FP) MOVL CX, y+8(FP) JMP runtime·goPanicExtendSlice3CU(SB) #ifdef GOOS_android // Use the free TLS_SLOT_APP slot #2 on Android Q. // Earlier androids are set up in gcc_android.c. DATA runtime·tls_g+0(SB)/4, $8 GLOBL runtime·tls_g+0(SB), NOPTR, $4 #endif #ifdef GOOS_windows GLOBL runtime·tls_g+0(SB), NOPTR, $4 #endif
Save File
Cancel