known to the system compiler (for example, all the GNU C extensions) as
well as the system-specific header locations and system-specific
pre-#defined macros. This is certainly possible to do, but it is an
enormous amount of work.

Cgo takes a different approach. It determines the meaning of C
identifiers not by parsing C code but by feeding carefully constructed
programs into the system C compiler and interpreting the generated

	for i := 0; i < len(bufsizes); i++ {
		for j := 0; j < len(bufsizes); j++ {
			nwrite := bufsizes[i]
			bs := bufsizes[j]

			// Write nwrite bytes using buffer size bs.
			// Check that the right amount makes it out
			// and that the data is correct.

			w.Reset()
			buf := NewWriterSize(w, bs)
			context := fmt.Sprintf("nwrite=%d bufsize=%d", nwrite, bs)
			n, e1 := buf.Write(data[0:nwrite])

	}
}

var stringFromGo string

//export goWithString
func goWithString(s string) {
	stringFromGo = s
}

func testCallbackStack(t *testing.T) {
	// Make cgo call and callback with different amount of stack available.
	// We do not do any explicit checks, just ensure that it does not crash.
	for _, f := range splitTests {
		f()
	}
}

//export goStackCheck
func goStackCheck() {

		;;
	"wasmer")
		exec wasmer run --dir=/ --env PWD="$PWD" --env PATH="$PATH" ${GOWASIRUNTIMEARGS:-} "$1" -- "${@:2}"
		;;
	"wazero")
		exec wazero run -mount /:/ -env-inherit -cachedir "${TMPDIR:-/tmp}"/wazero ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
		;;
	"wasmtime" | "")

pkg syscall (darwin-arm64), const SYS_UNDELETE ideal-int
pkg syscall (darwin-arm64), const SYS_UNLINK = 10
pkg syscall (darwin-arm64), const SYS_UNLINK ideal-int
pkg syscall (darwin-arm64), const SYS_UNMOUNT = 159
pkg syscall (darwin-arm64), const SYS_UNMOUNT ideal-int
pkg syscall (darwin-arm64), const SYS_UTIMES = 138
pkg syscall (darwin-arm64), const SYS_UTIMES ideal-int
pkg syscall (darwin-arm64), const SYS_VFORK = 66

pkg syscall (freebsd-arm64), const SYS_UNLINKAT = 503
pkg syscall (freebsd-arm64), const SYS_UNLINKAT ideal-int
pkg syscall (freebsd-arm64), const SYS_UNMOUNT = 22
pkg syscall (freebsd-arm64), const SYS_UNMOUNT ideal-int
pkg syscall (freebsd-arm64), const SYS_UTIMENSAT = 547
pkg syscall (freebsd-arm64), const SYS_UTIMENSAT ideal-int
pkg syscall (freebsd-arm64), const SYS_UTIMES = 138

As of Go 1.23 (`winsymlink=1`), mount points no longer have [`os.ModeSymlink`](/pkg/os#ModeSymlink)
set, and reparse points that are not symlinks, Unix sockets, or dedup files now
always have [`os.ModeIrregular`](/pkg/os#ModeIrregular) set. As a result of these changes,
[`filepath.EvalSymlinks`](/pkg/path/filepath#EvalSymlinks) no longer evaluates
mount points, which was a source of many inconsistencies and bugs.

pkg syscall (freebsd-riscv64), const SYS_UNLINKAT = 503 #53466
pkg syscall (freebsd-riscv64), const SYS_UNLINKAT ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_UNMOUNT = 22 #53466
pkg syscall (freebsd-riscv64), const SYS_UNMOUNT ideal-int #53466
pkg syscall (freebsd-riscv64), const SYS_UTIMENSAT = 547 #53466
pkg syscall (freebsd-riscv64), const SYS_UTIMENSAT ideal-int #53466

		tok := p.next()
		ext = tok.String()
	}
	if p.peek() == lex.LSH {
		// parses left shift amount applied after extension: <<Amount
		p.get(lex.LSH)
		tok := p.get(scanner.Int)
		amount, err := strconv.ParseInt(tok.String(), 10, 16)
		if err != nil {
			p.errorf("parsing left shift amount: %s", err)
		}
		num = int16(amount)
	} else if p.peek() == '[' {
		// parses an element: [Index]
		p.get('[')

// [Writer.WriteHeader] begins a new file with the provided [Header],
// and then Writer can be treated as an io.Writer to supply that file's data.
type Writer struct {
	w    io.Writer
	pad  int64      // Amount of padding to write after current file entry
	curr fileWriter // Writer for current file entry
	hdr  Header     // Shallow copy of Header that is safe for mutations
	blk  block      // Buffer to use as temporary local storage