// 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.

TEXT _rt0_386(SB),7,$0
	// copy arguments forward on an even stack
	MOVL	0(SP), AX		// argc
	LEAL	4(SP), BX		// argv
	SUBL	$128, SP		// plenty of scratch
	ANDL	$~7, SP
	MOVL	AX, 120(SP)		// save argc, argv away
	MOVL	BX, 124(SP)

/*
	// write "go386\n"
	PUSHL	$6
	PUSHL	$hello(SB)
	PUSHL	$1
	CALL	sys·write(SB)
	POPL	AX
	POPL	AX
	POPL	AX
*/

	CALL	ldt0setup(SB)

	// set up %fs to refer to that ldt entry
	MOVL	$(7*8+7), AX
	MOVW	AX, FS

	// store through it, to make sure it works
	MOVL	$0x123, 0(FS)
	MOVL	tls0(SB), AX
	CMPL	AX, $0x123
	JEQ	ok
	MOVL	AX, 0
ok:

	// set up m and g "registers"
	// g is 0(FS), m is 4(FS)
	LEAL	g0(SB), CX
	MOVL	CX, 0(FS)
	LEAL	m0(SB), AX
	MOVL	AX, 4(FS)

	// save m->g0 = g0
	MOVL	CX, 0(AX)

	// create istack out of the OS stack
	LEAL	(-8192+104)(SP), AX	// TODO: 104?
	MOVL	AX, 0(CX)	// 8(g) is stack limit (w 104b guard)
	MOVL	SP, 4(CX)	// 12(g) is base
	CALL	emptyfunc(SB)	// fault if stack check is wrong

	// convention is D is always cleared
	CLD

	CALL	check(SB)

	// saved argc, argv
	MOVL	120(SP), AX
	MOVL	AX, 0(SP)
	MOVL	124(SP), AX
	MOVL	AX, 4(SP)
	CALL	args(SB)
	CALL	osinit(SB)
	CALL	schedinit(SB)

	// create a new goroutine to start program
	PUSHL	$mainstart(SB)	// entry
	PUSHL	$8	// arg size
	CALL	sys·newproc(SB)
	POPL	AX
	POPL	AX

	// start this M
	CALL	mstart(SB)

	INT $3
	RET

TEXT mainstart(SB),7,$0
	CALL	main·init(SB)
	CALL	initdone(SB)
	CALL	main·main(SB)
	PUSHL	$0
	CALL	sys·Exit(SB)
	POPL	AX
	INT $3
	RET

TEXT	sys·Breakpoint(SB),7,$0
	BYTE $0xcc
	RET

// go-routine
TEXT	gogo(SB), 7, $0
	MOVL	4(SP), AX	// gobuf
	MOVL	0(AX), SP	// restore SP
	MOVL	4(AX), AX
	MOVL	AX, 0(SP)	// put PC on the stack
	MOVL	$1, AX
	RET

TEXT gosave(SB), 7, $0
	MOVL	4(SP), AX	// gobuf
	MOVL	SP, 0(AX)	// save SP
	MOVL	0(SP), BX
	MOVL	BX, 4(AX)	// save PC
	MOVL	$0, AX	// return 0
	RET

// support for morestack

// return point when leaving new stack.
// save AX, jmp to lesstack to switch back
TEXT	retfromnewstack(SB),7,$0
	MOVL	4(FS), BX	// m
	MOVL	AX, 8(BX)	// save AX in m->cret
	JMP	lessstack(SB)

// gogo, returning 2nd arg instead of 1
TEXT gogoret(SB), 7, $0
	MOVL	8(SP), AX	// return 2nd arg
	MOVL	4(SP), BX	// gobuf
	MOVL	0(BX), SP	// restore SP
	MOVL	4(BX), BX
	MOVL	BX, 0(SP)	// put PC on the stack
	RET

TEXT setspgoto(SB), 7, $0
	MOVL	4(SP), AX	// SP
	MOVL	8(SP), BX	// fn to call
	MOVL	12(SP), CX	// fn to return
	MOVL	AX, SP
	PUSHL	CX
	JMP	BX
	POPL	AX
	RET

// bool cas(int32 *val, int32 old, int32 new)
// Atomically:
//	if(*val == old){
//		*val = new;
//		return 1;
//	}else
//		return 0;
TEXT cas(SB), 7, $0
	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

// void jmpdefer(byte*);
// 1. pop the caller
// 2. sub 5 bytes from the callers return
// 3. jmp to the argument
TEXT jmpdefer(SB), 7, $0
	MOVL	4(SP), AX	// function
	ADDL	$(4+56), SP	// pop saved PC and callers frame
	SUBL	$5, (SP)	// reposition his return address
	JMP	AX		// and goto function

TEXT	sys·memclr(SB),7,$0
	MOVL	4(SP), DI		// arg 1 addr
	MOVL	8(SP), CX		// arg 2 count
	ADDL	$3, CX
	SHRL	$2, CX
	MOVL	$0, AX
	CLD
	REP
	STOSL
	RET

TEXT	sys·getcallerpc+0(SB),7,$0
	MOVL	x+0(FP),AX		// addr of first arg
	MOVL	-4(AX),AX		// get calling pc
	RET

TEXT	sys·setcallerpc+0(SB),7,$0
	MOVL	x+0(FP),AX		// addr of first arg
	MOVL	x+4(FP), BX
	MOVL	BX, -4(AX)		// set calling pc
	RET

TEXT ldt0setup(SB),7,$16
	// 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.
	MOVL	$7, 0(SP)
	LEAL	tls0(SB), AX
	MOVL	AX, 4(SP)
	MOVL	$32, 8(SP)	// sizeof(tls array)
	CALL	setldt(SB)
	RET

GLOBL m0+0(SB), $1024
GLOBL g0+0(SB), $1024

GLOBL tls0+0(SB), $32

TEXT emptyfunc(SB),0,$0
	RET

TEXT	abort(SB),7,$0
	INT $0x3

DATA hello+0(SB)/8, $"go386\n\z\z"
GLOBL hello+0(SB), $8