fail for reasons that are irrelevant when using external linking mode.

The final program will be a dynamic executable, so that cmd/link can avoid
needing to process arbitrary .o files. It only needs to process the .o
files generated from C files that cgo writes, and those are much more
limited in the ELF or other features that they use.

In essence, the _cgo_import.o file includes the extra linking

		if err := syscall.Exec(os.Args[0], argv, os.Environ()); err != nil {
			t.Fatal(err)
		}
	}

	var cmds []*exec.Cmd
	defer func() {
		for _, cmd := range cmds {
			cmd.Process.Kill()
		}
	}()

	args := append(append([]string(nil), os.Args[1:]...), "-test.run=^Test18146$")
	for n := attempts; n > 0; n-- {
		cmd := exec.Command(os.Args[0], args...)

			truncate(path, length, callback) { callback(enosys()); },
			unlink(path, callback) { callback(enosys()); },
			utimes(path, atime, mtime, callback) { callback(enosys()); },
		};
	}

	if (!globalThis.process) {
		globalThis.process = {
			getuid() { return -1; },
			getgid() { return -1; },
			geteuid() { return -1; },
			getegid() { return -1; },
			getgroups() { throw enosys(); },
			pid: -1,
			ppid: -1,

pkg syscall (netbsd-arm64-cgo), const PRIO_PGRP = 1
pkg syscall (netbsd-arm64-cgo), const PRIO_PGRP ideal-int
pkg syscall (netbsd-arm64-cgo), const PRIO_PROCESS = 0
pkg syscall (netbsd-arm64-cgo), const PRIO_PROCESS ideal-int
pkg syscall (netbsd-arm64-cgo), const PRIO_USER = 2
pkg syscall (netbsd-arm64-cgo), const PRIO_USER ideal-int
pkg syscall (netbsd-arm64-cgo), const PROT_EXEC = 4

variable that is earliest in declaration order and ready for initialization,
until there are no variables ready for initialization.
</p>

<p>
If any variables are still uninitialized when this
process ends, those variables are part of one or more initialization cycles,
and the program is not valid.
</p>

<p>
Multiple variables on the left-hand side of a variable declaration initialized

	}
	word, cond = p.lex.Text(), ""
	operands = scratch[:0]
	// Zero or more comma-separated operands, one per loop.
	nesting := 0
	colon := -1
	for tok != '\n' && tok != ';' {
		// Process one operand.
		var items []lex.Token
		if cap(operands) > len(operands) {
			// Reuse scratch items slice.
			items = operands[:cap(operands)][len(operands)][:0]
		} else {
			items = make([]lex.Token, 0, 3)

</pre>

<p>
A type argument <code>A<sub>k</sub></code> may be a composite type,
containing other bound type parameters <code>P<sub>k</sub></code> as element types
(or even be just another bound type parameter).
In a process of repeated simplification, the bound type parameters in each type
argument are substituted with the respective type arguments for those type
parameters until each type argument is free of bound type parameters.
</p>

pkg syscall (linux-arm), const SYS_PREAD64 = 180
pkg syscall (linux-arm), const SYS_PREADV = 361
pkg syscall (linux-arm), const SYS_PRLIMIT64 = 369
pkg syscall (linux-arm), const SYS_PROCESS_VM_READV = 376
pkg syscall (linux-arm), const SYS_PROCESS_VM_WRITEV = 377
pkg syscall (linux-arm), const SYS_PSELECT6 = 335
pkg syscall (linux-arm), const SYS_PTRACE = 26
pkg syscall (linux-arm), const SYS_PWRITE64 = 181

globalThis.crypto ??= require("crypto");

require("./wasm_exec");

const go = new Go();
go.argv = process.argv.slice(2);
go.env = Object.assign({ TMPDIR: require("os").tmpdir() }, process.env);
go.exit = process.exit;
WebAssembly.instantiate(fs.readFileSync(process.argv[2]), go.importObject).then((result) => {
	process.on("exit", (code) => { // Node.js exits if no event handler is pending
		if (code === 0 && !go.exited) {

pkg syscall (darwin-386), const ImplementsGetwd = true
pkg syscall (darwin-386), const PRIO_PGRP = 1
pkg syscall (darwin-386), const PRIO_PGRP ideal-int
pkg syscall (darwin-386), const PRIO_PROCESS = 0
pkg syscall (darwin-386), const PRIO_PROCESS ideal-int
pkg syscall (darwin-386), const PRIO_USER = 2
pkg syscall (darwin-386), const PRIO_USER ideal-int
pkg syscall (darwin-386), const SizeofICMPv6Filter = 32