var x1 C.jobject = 0 // Note: 0, not nil. That makes sure we use uintptr for these types.
	_ = x1
	var x2 C.jclass = 0
	_ = x2
	var x3 C.jthrowable = 0
	_ = x3
	var x4 C.jstring = 0
	_ = x4
	var x5 C.jarray = 0
	_ = x5
	var x6 C.jbooleanArray = 0
	_ = x6
	var x7 C.jbyteArray = 0
	_ = x7
	var x8 C.jcharArray = 0
	_ = x8
	var x9 C.jshortArray = 0
	_ = x9
	var x10 C.jintArray = 0
	_ = x10

passing a pointer to a field in a struct, the Go memory in question is
the memory occupied by the field, not the entire struct. When passing a
pointer to an element in an array or slice, the Go memory in question is
the entire array or the entire backing array of the slice.

C code may keep a copy of a Go pointer only as long as the memory it
points to is pinned.

C code may not keep a copy of a Go pointer after the call returns,

var a [10]int
s1 := a[3:7]   // underlying array of s1 is array a; &s1[2] == &a[5]
s2 := s1[1:4]  // underlying array of s2 is underlying array of s1 which is array a; &s2[1] == &a[5]
s2[1] = 42     // s2[1] == s1[2] == a[5] == 42; they all refer to the same underlying array element
</pre>


<h4>Full slice expressions</h4>

<p>

//
// For some arguments, such as a string literal or a simple array expression, the
// result can be a constant. See the Go language specification's "Length and
// capacity" section for details.
func len(v Type) int

// The cap built-in function returns the capacity of v, according to its type:
//
//	Array: the number of elements in v (same as len(v)).
//	Pointer to array: the number of elements in *v (same as len(v)).

should be used instead.
</li>
</ol>

<h4 id="Conversions_from_slice_to_array_or_array_pointer">Conversions from slice to array or array pointer</h4>

<p>
Converting a slice to an array yields an array containing the elements of the underlying array of the slice.
Similarly, converting a slice to an array pointer yields a pointer to the underlying array of the slice.

		includes:        append([]string{filepath.Dir(name)}, flags.I...),
		beginningOfLine: true,
		macros:          predefine(flags.D),
	}
}

// predefine installs the macros set by the -D flag on the command line.
func predefine(defines flags.MultiFlag) map[string]*Macro {
	macros := make(map[string]*Macro)
	for _, name := range defines {
		value := "1"
		i := strings.IndexRune(name, '=')
		if i > 0 {

pkg debug/elf, const DT_FINI = 13
pkg debug/elf, const DT_FINI_ARRAY = 26
pkg debug/elf, const DT_FINI_ARRAYSZ = 28
pkg debug/elf, const DT_FLAGS = 30
pkg debug/elf, const DT_HASH = 4
pkg debug/elf, const DT_HIOS = 1879044096
pkg debug/elf, const DT_HIPROC = 2147483647
pkg debug/elf, const DT_INIT = 12
pkg debug/elf, const DT_INIT_ARRAY = 25
pkg debug/elf, const DT_INIT_ARRAYSZ = 27
pkg debug/elf, const DT_JMPREL = 23

pkg syscall (freebsd-386-cgo), type Rusage struct, Ixrss int32
pkg syscall (freebsd-386-cgo), type Rusage struct, Majflt int32
pkg syscall (freebsd-386-cgo), type Rusage struct, Maxrss int32
pkg syscall (freebsd-386-cgo), type Rusage struct, Minflt int32
pkg syscall (freebsd-386-cgo), type Rusage struct, Msgrcv int32
pkg syscall (freebsd-386-cgo), type Rusage struct, Msgsnd int32

	"jthrowable":    "jobject",
	"jstring":       "jobject",
	"jarray":        "jobject",
	"jbooleanArray": "jarray",
	"jbyteArray":    "jarray",
	"jcharArray":    "jarray",
	"jshortArray":   "jarray",
	"jintArray":     "jarray",
	"jlongArray":    "jarray",
	"jfloatArray":   "jarray",
	"jdoubleArray":  "jarray",
	"jobjectArray":  "jarray",
	"jweak":         "jobject",

pkg debug/elf, const DT_FINI DynTag
pkg debug/elf, const DT_FINI_ARRAY DynTag
pkg debug/elf, const DT_FINI_ARRAYSZ DynTag
pkg debug/elf, const DT_FLAGS DynTag
pkg debug/elf, const DT_HASH DynTag
pkg debug/elf, const DT_HIOS DynTag
pkg debug/elf, const DT_HIPROC DynTag
pkg debug/elf, const DT_INIT DynTag
pkg debug/elf, const DT_INIT_ARRAY DynTag
pkg debug/elf, const DT_INIT_ARRAYSZ DynTag