// The biggest risk is having a write barrier in the debug call
	// injection test code fire, because it runs in a signal handler
	// and may not have a P.
	//
	// We use 8 Ps so there's room for the debug call worker,
	// something that's trying to preempt the call worker, and the
	// goroutine that's trying to stop the call worker.
	ogomaxprocs := runtime.GOMAXPROCS(8)
	ogcpercent := debug.SetGCPercent(-1)

                   builder.getBoolAttr(true));
}

// Encapsulate the first partitioned call that can be reached from
// `func` and is with compilation markers in a device cluster. For nested calls,
// if the outermost one has the markers, encapsulates the outermost call and
// returns. Otherwise, we'll keep going through inner calls until we found one.

// and returns the receiver, so that objects can be built by chaining "With" function invocations.
// If called multiple times, the ParamKind field is set to the value of the last call.
func (b *ValidatingAdmissionPolicySpecApplyConfiguration) WithParamKind(value *ParamKindApplyConfiguration) *ValidatingAdmissionPolicySpecApplyConfiguration {
	b.ParamKind = value
	return b
}

import (
	"internal/abi"
	"internal/stringslite"
	"unsafe"
)

// InjectDebugCall injects a debugger call to fn into g. regArgs must
// contain any arguments to fn that are passed in registers, according
// to the internal Go ABI. It may be nil if no arguments are passed in
// registers to fn. args must be a pointer to a valid call frame (including
// arguments and return space) for fn, or nil. tkill must be a function that

      address = address,
      proxy = proxy,
      socketAddress = socketAddress,
    )
  }

  fun newChain(call: RealCall): RealInterceptorChain {
    return RealInterceptorChain(
      call = call,
      interceptors = listOf(),
      index = 0,
      exchange = null,
      request = call.request(),
      connectTimeoutMillis = 10_000,
      readTimeoutMillis = 10_000,
      writeTimeoutMillis = 10_000,
    )

        )
        .dns(dns)
        .build()

    server.enqueue(MockResponse())

    val url = server.url("/").newBuilder().host("localhost.localdomain").build()
    val call = client.newCall(Request(url = url))
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()

    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.handshakeServerNames).containsExactly(url.host)
  }

	// We want to trigger a bounds check on the g0 stack. To do this, we
	// need to call a splittable function through systemstack().
	// SetGCPercent contains such a systemstack call.
	gogc := debug.SetGCPercent(100)
	debug.SetGCPercent(gogc)
}

// Regression test for https://go.dev/issue/62440. It should be possible for C
// threads to call into Go from different stacks without crashing due to g0
// stack bounds checks.
//

// MODULE: context

// FILE: context.kt
object Foo {
    fun test() {
        <caret_context>val x = 0
    }

    fun call() {}
}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION

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

#include "go_asm.h"
#include "go_tls.h"
#include "funcdata.h"
#include "textflag.h"

// If !iscgo, this is a no-op.
//
// NOTE: mcall() assumes this clobbers only X31 (REG_TMP).
TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0
#ifndef GOOS_openbsd
	MOVB	runtime·iscgo(SB), X31
	BEQZ	X31, nocgo
#endif
	MOV	g, runtime·tls_g(SB)
nocgo:
	RET

// MODULE: context

// FILE: context.kt
fun test() {
    <caret_context>call("foo")
}

fun call(text: String) {}


// MODULE: main
// MODULE_KIND: CodeFragment
// CONTEXT_MODULE: context

// FILE: fragment.kt
// CODE_FRAGMENT_KIND: EXPRESSION
// CODE_FRAGMENT_FOREIGN_VALUE: foo_DebugLabel(Ljava/lang/String;)