}
			buf.WriteByte(']')
		}

	case *types.TypeParam:
		// Type parameter names may change, so use a placeholder instead.
		fmt.Fprintf(buf, "$%d", typ.Index())

	default:
		panic(fmt.Sprintf("unknown type %T", typ))
	}
}

func (w *Walker) writeSignature(buf *bytes.Buffer, sig *types.Signature) {
	if tparams := sig.TypeParams(); tparams != nil {
		w.writeTypeParams(buf, tparams, true)
	}

pkg syscall (freebsd-arm64), const DT_REG ideal-int
pkg syscall (freebsd-arm64), const DT_SOCK = 12
pkg syscall (freebsd-arm64), const DT_SOCK ideal-int
pkg syscall (freebsd-arm64), const DT_UNKNOWN = 0
pkg syscall (freebsd-arm64), const DT_UNKNOWN ideal-int
pkg syscall (freebsd-arm64), const DT_WHT = 14
pkg syscall (freebsd-arm64), const DT_WHT ideal-int
pkg syscall (freebsd-arm64), const E2BIG = 7

pkg syscall (freebsd-riscv64), const DT_SOCK = 12 #53466
pkg syscall (freebsd-riscv64), const DT_SOCK ideal-int #53466
pkg syscall (freebsd-riscv64), const DT_UNKNOWN = 0 #53466
pkg syscall (freebsd-riscv64), const DT_UNKNOWN ideal-int #53466
pkg syscall (freebsd-riscv64), const DT_WHT = 14 #53466
pkg syscall (freebsd-riscv64), const DT_WHT ideal-int #53466
pkg syscall (freebsd-riscv64), const E2BIG = 7 #53466

func test1435(t *testing.T) {
	if syscall.Getuid() != 0 {
		t.Skip("skipping root only test")
	}
	if testing.Short() && testenv.Builder() != "" && os.Getenv("USER") == "swarming" {
		// The Go build system's swarming user is known not to be root.
		// Unfortunately, it sometimes appears as root due the current
		// implementation of a no-network check using 'unshare -n -r'.
		// Since this test does need root to work, we need to skip it.

---
title: "Go, Backwards Compatibility, and GODEBUG"
layout: article
---

<!--
This document is kept in the Go repo, not x/website,
because it documents the full list of known GODEBUG settings,
which are tied to a specific release.
-->

## Introduction {#intro}

Go's emphasis on backwards compatibility is one of its key strengths.
There are, however, times when we cannot maintain complete compatibility.

		// to an index into the r.fileList entry that we are
		// building. They are used to mark duplicate entries.
		files := make(map[string]int)
		knownDirs := make(map[string]int)

		// dirs[name] is true if name is known to be a directory,
		// because it appears as a prefix in a path.
		dirs := make(map[string]bool)

		for _, file := range r.File {
			isDir := len(file.Name) > 0 && file.Name[len(file.Name)-1] == '/'

	instructions["BL"] = obj.ACALL
	// MCR differs from MRC by the way fields of the word are encoded.
	// (Details in arm.go). Here we add the instruction so parse will find
	// it, but give it an opcode number known only to us.
	instructions["MCR"] = aMCR

	return &Arch{
		LinkArch:       &arm.Linkarm,
		Instructions:   instructions,
		Register:       register,
		RegisterPrefix: registerPrefix,

pkg debug/pe, const IMAGE_FILE_MACHINE_SH4 = 422
pkg debug/pe, const IMAGE_FILE_MACHINE_SH5 = 424
pkg debug/pe, const IMAGE_FILE_MACHINE_THUMB = 450
pkg debug/pe, const IMAGE_FILE_MACHINE_UNKNOWN = 0
pkg debug/pe, const IMAGE_FILE_MACHINE_WCEMIPSV2 = 361
pkg debug/pe, type COFFSymbol struct
pkg debug/pe, type COFFSymbol struct, Name [8]uint8
pkg debug/pe, type COFFSymbol struct, NumberOfAuxSymbols uint8

</p>

<pre>
const (
	AAND = obj.ABaseARM + obj.A_ARCHSPECIFIC + iota
	AEOR
	ASUB
	ARSB
	AADD
	...
</pre>

<p>
This is the list of instructions and their spellings as known to the assembler and linker for that architecture.
Each instruction begins with an initial capital <code>A</code> in this list, so <code>AAND</code>
represents the bitwise and instruction,

	switch {
	case major == "0" && (minor == "0" || minor == "1"):
		is1x0 = false
	case major == "1" && minor == "0":
		is1x0 = true
	case major != "" || minor != "":
		return nil, nil // Unknown GNU sparse PAX version
	case hdr.PAXRecords[paxGNUSparseMap] != "":
		is1x0 = false // 0.0 and 0.1 did not have explicit version records, so guess
	default:
		return nil, nil // Not a PAX format GNU sparse file.
	}