{
					Name:   "plaintext",
					Call:   mkCall(8000, simulation.Plaintext),
					Result: simulation.Result{Error: simulation.ErrNoFilterChain},
				},
				{
					Name:   "mtls",
					Call:   mkCall(8000, simulation.MTLS),
					Result: simulation.Result{ClusterMatched: "InboundPassthroughCluster"},
				},
			},
		},
		{
			name:   "global permissive",
			config: paPermissive,

	}
	for !q.Empty() {
		fn := q.PopLeft().Func

		// Check fn.
		if fn.WBPos.IsKnown() {
			var err strings.Builder
			call := funcs[fn]
			for call.target != nil {
				fmt.Fprintf(&err, "\n\t%v: called by %v", base.FmtPos(call.lineno), call.target.Nname)
				call = funcs[call.target]
			}
			// Seeing this error in a failed CI run? It indicates that
			// a function in the runtime package marked nowritebarrierrec

	if x < 0 {
		return
	}
	gg(x - 1) // ERROR "inlining call to gg" "inlining call to hh"
}
func gg(x int) { // ERROR "can inline gg"
	hh(x - 1) // ERROR "inlining call to hh" "inlining call to ff"
}
func hh(x int) { // ERROR "can inline hh"
	ff(x - 1) // ERROR "inlining call to ff" "inlining call to gg"
}

// Issue #14768 - make sure we can inline for loops.

	}

	if id := funcIdent(fun); id != nil {
		if lit := funcLitInScope(id); lit != nil { // function lit in variable?
			return &asyncCall{region: lit, async: call, scope: lit, fun: fun}
		}
	}

	// Check within t.Run(name, fun) for calls to t.Forbidden,
	// e.g. t.Run(name, func(t *testing.T){ t.Forbidden() })
	return &asyncCall{region: call, async: call, scope: fun, fun: fun}
}

	call := libcall{
		fn:   fn,
		n:    nargs,
		args: uintptr(unsafe.Pointer(&a1)),
	}
	asmcgocall(unsafe.Pointer(&asmsysvicall6x), unsafe.Pointer(&call))
	return call.r1, call.r2, call.err
}

// TODO(aram): Once we remove all instances of C calling sysvicallN, make
// sysvicallN return errors and replace the body of the following functions
// with calls to sysvicallN.

//go:nosplit

                                if (!call.isImplicitThis()) {
                                    restrict(call, formatErrorMessage(BASE_MESSAGE));
                                } else {
                                    ConstantExpression lineNumberExpression = new ConstantExpression(call.getLineNumber(), true);

	MOVW	0(R0), R0		// arg 1 - fd
	CALL	libc_write(SB)
	CMP	$-1, R0
	BNE	noerr
	CALL	libc_errno(SB)
	MOVW	(R0), R0		// errno
	NEG	R0, R0			// caller expects negative errno value
noerr:
	RET

TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
	MOVW	8(R0), R1		// arg 2 - flags
	MOVD	0(R0), R0		// arg 1 - filedes
	CALL	libc_pipe2(SB)
	CMP	$-1, R0
	BNE	noerr
	CALL	libc_errno(SB)
	MOVW	(R0), R0		// errno

  }

  @Override public void callStart(Call call) {
    printEvent("callStart");
  }

  @Override public void callEnd(Call call) {
    printEvent("callEnd");
  }

  @Override public void dnsStart(Call call, String domainName) {
    printEvent("dnsStart");
  }

  @Override public void dnsEnd(Call call, String domainName, List<InetAddress> inetAddressList) {
    printEvent("dnsEnd");

        port:
          number: 80
`,
			calls: []simulation.Expect{
				{
					Name: "a",
					Call: simulation.Call{
						Port:       80,
						HostHeader: "a.example.com",
						Protocol:   simulation.HTTP,
					},
					Result: simulation.Result{ClusterMatched: "outbound|80||a.default"},
				},
				{
					Name: "b",
					Call: simulation.Call{
						Port:       80,

	MOV	8(X10), X11		// arg 2 - old
	MOV	0(X10), X10		// arg 1 - new
	CALL	libc_sigaltstack(SB)
	MOV	$-1, X5
	BNE	X5, X10, 3(PC)
	MOV	$0, X5			// crash on failure
	MOV	X5, (X5)
	RET

TEXT runtime·issetugid_trampoline(SB),NOSPLIT,$0
	MOV	X10, X9			// pointer to args
	CALL	libc_issetugid(SB)
	MOVW	X10, 0(X9)		// return value
	RET

// syscall calls a function in libc on behalf of the syscall package.