2020-06-29T23:37:27.336149Z	info	ClientConn switching balancer to "pick_first"
2020-06-29T23:37:27.336155Z	info	Channel switches to new LB policy "pick_first"
2020-06-29T23:37:27.336189Z	info	Subchannel Connectivity change to CONNECTING
2020-06-29T23:37:27.336222Z	info	Starting gateway SDS

env TESTGO_VERSION_SWITCH=loop
! go version
stderr -count=10 '^go: switching from go1.21.1 to go1.21.99 \[depth 9[0-9]\]$'
stderr -count=1 '^go: switching from go1.21.1 to go1.21.99 \[depth 100\]$'
stderr '^go: too many toolchain switches$'

[short] skip

# Internal env vars should not leak to go test or go run.
env TESTGO_VERSION_SWITCH=switch
go version
stdout go1.21.99
go test
stdout clean
go run .
stdout clean

-- go.mod --

	// already running on CPU and there can be lots of them, so a woken up
	// waiter has good chances of losing. In such case it is queued at front
	// of the wait queue. If a waiter fails to acquire the mutex for more than 1ms,
	// it switches mutex to the starvation mode.
	//
	// In starvation mode ownership of the mutex is directly handed off from
	// the unlocking goroutine to the waiter at the front of the queue.

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

// Tests coroutine switches.

//go:build ignore

package main

import (
	"iter"
	"log"
	"os"
	"runtime/trace"
	"sync"
)

func main() {
	// Start tracing.
	if err := trace.Start(os.Stdout); err != nil {
		log.Fatalf("failed to start tracing: %v", err)
	}

// 	return b[0], err
// }
//
// // type assertions and type switches over generic types are strict
// type I3 interface {
//         m(int)
// }
//
// type I4 interface {
//         m() int // different signature from I3.m
// }
//
// func _[T I3](x I3, p T) {
//         // type assertions and type switches over interfaces are not strict
//         _ = x.(I4)
//         switch x.(type) {

	MOVD	dst+0(FP), RARG0
	MOVD	src+8(FP), RARG1
	MOVD	sz+16(FP), RARG2
	// void __msan_memmove(void *dst, void *src, uintptr_t sz);
	MOVD	$__msan_memmove(SB), FARG
	JMP	msancall<>(SB)

// Switches SP to g0 stack and calls (FARG). Arguments already set.
TEXT	msancall<>(SB), NOSPLIT, $0-0
	MOVD	RSP, R19                  // callee-saved
	CBZ	g, g0stack                // no g, still on a system stack
	MOVD	g_m(g), R10

//go:build darwin || (openbsd && !mips64)

package runtime

import "unsafe"

// Call fn with arg as its argument. Return what fn returns.
// fn is the raw pc value of the entry point of the desired function.
// Switches to the system stack, if not already there.
// Preserves the calling point as the location where a profiler traceback will begin.
//
//go:nosplit
func libcCall(fn, arg unsafe.Pointer) int32 {

	// ITab is an expression that yields a *runtime.itab value
	// representing the asserted type within the assertee expression's
	// original interface type.
	//
	// ITab is only used for assertions (including type switches) from
	// non-empty interface type to a concrete (i.e., non-interface)
	// type. For all other assertions, ITab is nil.
	ITab Node
}

func NewDynamicType(pos src.XPos, rtype Node) *DynamicType {

	MOVD	addr+0(FP), RARG0
	MOVD	n+8(FP), RARG1
	// void __asan_register_globals_go(void *addr, uintptr_t n);
	MOVD	$__asan_register_globals_go(SB), FARG
	JMP	asancall<>(SB)

// Switches SP to g0 stack and calls (FARG). Arguments already set.
TEXT	asancall<>(SB), NOSPLIT, $0-0
	MOVD	RSP, R19                  // callee-saved
	CBZ	g, g0stack                // no g, still on a system stack
	MOVD	g_m(g), R10

TEXT	runtime·asanregisterglobals(SB), NOSPLIT, $0-16
	MOV	addr+0(FP), X10
	MOV	n+8(FP), X11
	// void __asan_register_globals_go(void *addr, uintptr_t n);
	MOV	$__asan_register_globals_go(SB), X14
	JMP	asancall<>(SB)

// Switches SP to g0 stack and calls (X14). Arguments already set.
TEXT	asancall<>(SB), NOSPLIT, $0-0
	MOV	X2, X8		// callee-saved
	BEQZ	g, g0stack	// no g, still on a system stack
	MOV	g_m(g), X21
	MOV	m_g0(X21), X21