// license that can be found in the LICENSE file.

package main


func main() {
	fired := false; _ = fired;
}
/*
bug9.go:5: defaultlit: unknown literal: LITERAL-B0 a(1)
bug9.go:5: fatal error: addvar: n=NAME-fired G0 a(1) l(5) t=<N> nil

// It just does some low-level setup and then calls mstart.
// Note: called with the C calling convention.
TEXT runtime·mstart_stub(SB),NOSPLIT,$200
	// X10 points to the m.
	// We are already on m's g0 stack.

	// Save callee-save registers (X8, X9, X18..X27, F8, F9, F18..F27)
	MOV	X8, (1*8)(X2)
	MOV	X9, (2*8)(X2)
	MOV	X18, (3*8)(X2)
	MOV	X19, (4*8)(X2)
	MOV	X20, (5*8)(X2)
	MOV	X21, (6*8)(X2)

	// switch to m->g0 & its stack, call fn
	MOVQ	g_m(R14), BX
	MOVQ	m_g0(BX), SI	// SI = g.m.g0
	CMPQ	SI, R14	// if g == m->g0 call badmcall
	JNE	goodm
	JMP	runtime·badmcall(SB)
goodm:
	MOVQ	R14, AX		// AX (and arg 0) = g
	MOVQ	SI, R14		// g = g.m.g0
	get_tls(CX)		// Set G in TLS
	MOVQ	R14, g(CX)
	MOVQ	(g_sched+gobuf_sp)(R14), SP	// sp = g0.sched.sp

	JMP	racecall<>(SB)

// Switches SP to g0 stack and calls (R9). Arguments already set.
// Clobbers R19, R20.
TEXT	racecall<>(SB), NOSPLIT|NOFRAME, $0-0
	MOVD	g_m(g), R10
	// Switch to g0 stack.
	MOVD	RSP, R19	// callee-saved, preserved across the CALL
	MOVD	R30, R20	// callee-saved, preserved across the CALL
	MOVD	m_g0(R10), R11
	CMP	R11, g
	BEQ	call	// already on g0
	MOVD	(g_sched+gobuf_sp)(R11), R12
	MOVD	R12, RSP

	ADD	$const_stackGuard, R0
	MOVD	R0, g_stackguard0(g)
	MOVD	R0, g_stackguard1(g)

	// set the per-goroutine and per-mach "registers"
	MOVD	$runtime·m0(SB), R0

	// save m->g0 = g0
	MOVD	g, m_g0(R0)
	// save m0 to g0->m
	MOVD	R0, g_m(g)

	BL	runtime·check(SB)

#ifdef GOOS_windows
	BL	runtime·wintls(SB)
#endif

	MOVW	8(RSP), R0	// copy argc
	MOVW	R0, -8(RSP)
	MOVD	16(RSP), R0		// copy argv

// It just does some low-level setup and then calls mstart.
// Note: called with the C calling convention.
TEXT runtime·mstart_stub(SB),NOSPLIT,$32
	// R3 points to the m.
	// We are already on m's g0 stack.

	// Go relies on R0 being $0.
	XOR	R0, R0

	// TODO(jsing): Save callee-save registers (R14-R31, F14-F31, V20-V31).

	MOVD    m_g0(R3), g
	BL	runtime·save_g(SB)

	BL	runtime·mstart(SB)

		println("BUG bug344b", y)
	}
	
	i = 1<<32
	if y := x << i; y != 0 {
		println("BUG bug344c", y)
	}
}
	

/*
typecheck [1008592b0]
.   INDREG a(1) l(15) x(24) tc(2) runtime.ret G0 string
bug343.go:15: internal compiler error: typecheck INDREG

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

// The stubs for the C functions read and write the same slot on the
// g0 stack when copying arguments in and out.

/*
#cgo CFLAGS: -fsanitize=thread
#cgo LDFLAGS: -fsanitize=thread

int Func1() {
	return 0;
}

void Func2(int x) {
	(void)x;
}
*/
import "C"

// It just does some low-level setup and then calls mstart.
// Note: called with the C calling convention.
TEXT runtime·mstart_stub(SB),NOSPLIT,$144
	// R0 points to the m.
	// We are already on m's g0 stack.

	// Save callee-save registers.
	SAVE_R19_TO_R28(8)
	SAVE_F8_TO_F15(88)

	MOVD    m_g0(R0), g
	BL	runtime·save_g(SB)

	BL	runtime·mstart(SB)

	// Restore callee-save registers.

//go:nowritebarrier
func newosproc(mp *m) {
	stk := unsafe.Pointer(mp.g0.stack.hi)
	if false {
		print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " thr_start=", abi.FuncPCABI0(thr_start), " id=", mp.id, " ostk=", &mp, "\n")
	}

	param := thrparam{
		start_func: abi.FuncPCABI0(thr_start),
		arg:        unsafe.Pointer(mp),
		stack_base: mp.g0.stack.lo,
		stack_size: uintptr(stk) - mp.g0.stack.lo,
		child_tid:  nil, // minit will record tid