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>

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"go/ast"
	"go/printer"
	"go/token"
	"os"
	"path/filepath"
	"strings"
)

// godefs returns the output for -godefs mode.
func (p *Package) godefs(f *File, args []string) string {
	var buf strings.Builder

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>"
	}

}

// Use a Scanner to implement a simple word-count utility by scanning the
// input as a sequence of space-delimited tokens.
func ExampleScanner_words() {
	// An artificial input source.
	const input = "Now is the winter of our discontent,\nMade glorious summer by this sun of York.\n"
	scanner := bufio.NewScanner(strings.NewReader(input))
	// Set the split function for the scanning operation.
	scanner.Split(bufio.ScanWords)
	// Count the words.

pkg go/parser, type Mode uint
pkg go/printer, const RawFormat Mode
pkg go/printer, const SourcePos Mode
pkg go/printer, const TabIndent Mode
pkg go/printer, const UseSpaces Mode
pkg go/printer, func Fprint(io.Writer, *token.FileSet, interface{}) error
pkg go/printer, method (*Config) Fprint(io.Writer, *token.FileSet, interface{}) error
pkg go/printer, type CommentedNode struct

// 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 go/parser, const ParseComments = 4
pkg go/parser, const SpuriousErrors = 32
pkg go/parser, const Trace = 8
pkg go/printer, const RawFormat = 1
pkg go/printer, const SourcePos = 8
pkg go/printer, const TabIndent = 2
pkg go/printer, const UseSpaces = 4
pkg go/printer, type Config struct, Indent int
pkg go/scanner, const ScanComments = 1
pkg go/token, const ADD = 12
pkg go/token, const ADD_ASSIGN = 23