the toolchain, such as a frame pointer.
The set of pseudo-registers is the same for all architectures:
</p>

<ul>

<li>
<code>FP</code>: Frame pointer: arguments and locals.
</li>

<li>
<code>PC</code>: Program counter:
jumps and branches.
</li>

<li>
<code>SB</code>: Static base pointer: global symbols.
</li>

<li>

func (b *Buffer) AvailableBuffer() []byte { return b.buf[len(b.buf):] }

// String returns the contents of the unread portion of the buffer
// as a string. If the [Buffer] is a nil pointer, it returns "<nil>".
//
// To build strings more efficiently, see the strings.Builder type.
func (b *Buffer) String() string {
	if b == nil {
		// Special case, useful in debugging.
		return "<nil>"
	}

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 sync/atomic, func LoadPointer(*unsafe.Pointer) unsafe.Pointer
pkg sync/atomic, func LoadUint32(*uint32) uint32
pkg sync/atomic, func LoadUint64(*uint64) uint64
pkg sync/atomic, func LoadUintptr(*uintptr) uintptr
pkg sync/atomic, func StoreInt32(*int32, int32)
pkg sync/atomic, func StoreInt64(*int64, int64)
pkg sync/atomic, func StorePointer(*unsafe.Pointer, unsafe.Pointer)
pkg sync/atomic, func StoreUint32(*uint32, uint32)

// const declaration. It is zero-indexed.
const iota = 0 // Untyped int.

// nil is a predeclared identifier representing the zero value for a
// pointer, channel, func, interface, map, or slice type.
var nil Type // Type must be a pointer, channel, func, interface, map, or slice type

// Type is here for the purposes of documentation only. It is a stand-in

-->

<p>
A <code>Pointer</code> is a <a href="#Pointer_types">pointer type</a> but a <code>Pointer</code>
value may not be <a href="#Address_operators">dereferenced</a>.
Any pointer or value of <a href="#Core_types">core type</a> <code>uintptr</code> can be
<a href="#Conversions">converted</a> to a type of core type <code>Pointer</code> and vice versa.

handles are equal, allowing programs to deduplicate values and reduce
their memory footprint.
Comparing two `Handle[T]` values is efficient, reducing down to a simple

		"test.nestedCall",
		"test.testCallbackCallersSEH",
		"test.TestCallbackCallersSEH",
	}
	pc := make([]uintptr, 100)
	n := 0
	nestedCall(func() {
		n = int(C.backtrace(C.DWORD(len(pc)), (*C.PVOID)(unsafe.Pointer(&pc[0]))))
	})
	got := make([]string, 0, n)
	for i := 0; i < n; i++ {
		f := runtime.FuncForPC(pc[i] - 1)
		if f == nil {
			continue
		}
		fname := f.Name()
		switch fname {
		case "goCallback":

pkg syscall (windows-386), const REG_SZ = 1
pkg syscall (windows-386), const SIGBUS = 7
pkg syscall (windows-386), const SIO_GET_EXTENSION_FUNCTION_POINTER = 3355443206
pkg syscall (windows-386), const SIO_GET_EXTENSION_FUNCTION_POINTER ideal-int
pkg syscall (windows-386), const SIO_GET_INTERFACE_LIST = 1074033791
pkg syscall (windows-386), const SOL_SOCKET = 65535

		return fmt.Errorf("codesign: %v", err)
	}
	return nil
}

// mountDevImage ensures a developer image is mounted on the device.
// The image contains the device lldb server for idevicedebugserverproxy
// to connect to.
func mountDevImage() error {
	// Check for existing mount.
	cmd := idevCmd(exec.Command("ideviceimagemounter", "-l", "-x"))
	out, err := cmd.CombinedOutput()
	if err != nil {