pkg syscall (freebsd-riscv64), type Statfs_t struct, Mntonname [1024]int8 #53466
pkg syscall (freebsd-riscv64), type Statfs_t struct, Namemax uint32 #53466
pkg syscall (freebsd-riscv64), type Statfs_t struct, Owner uint32 #53466
pkg syscall (freebsd-riscv64), type Statfs_t struct, Spare [10]uint64 #53466
pkg syscall (freebsd-riscv64), type Statfs_t struct, Syncreads uint64 #53466

				c -= 'a' - 'A'
			}
			b[i] = c
		}
		return b
	}
	return Map(unicode.ToUpper, s)
}

// ToLower returns a copy of the byte slice s with all Unicode letters mapped to
// their lower case.
func ToLower(s []byte) []byte {
	isASCII, hasUpper := true, false
	for i := 0; i < len(s); i++ {
		c := s[i]
		if c >= utf8.RuneSelf {
			isASCII = false
			break
		}

			rp = &r.buf[len(r.buf)-1]
		} else {
			rp.n++
		}
	}
	return len(p), nil
}

func memset(a []byte, b byte) {
	if len(a) == 0 {
		return
	}
	// Double, until we reach power of 2 >= len(a), same as bytes.Repeat,
	// but without allocation.
	a[0] = b
	for i, l := 1, len(a); i < l; i *= 2 {
		copy(a[i:], a[:i])
	}
}

			} else if nextReg != int(reg) {
				p.errorf("incontiguous register in ARM64 register list: %s", name)
			}
			regCnt++
			nextReg = (nextReg + 1) % 32
		case sys.ARM:
			// Parse the upper and lower bounds.
			lo := p.registerNumber(tok.String())
			hi := lo
			if p.peek() == '-' {
				p.next()
				hi = p.registerNumber(p.next().String())
			}
			if hi < lo {
				lo, hi = hi, lo
			}

If the divisor is a <a href="#Constants">constant</a>, it must not be zero.
If the divisor is zero at run time, a <a href="#Run_time_panics">run-time panic</a> occurs.
If the dividend is non-negative and the divisor is a constant power of 2,
the division may be replaced by a right shift, and computing the remainder may
be replaced by a bitwise AND operation:
</p>

<pre>
 x     x / 4     x % 4     x &gt;&gt; 2     x &amp; 3

pkg syscall (linux-386), const LINUX_REBOOT_CMD_HALT = 3454992675
pkg syscall (linux-386), const LINUX_REBOOT_CMD_KEXEC = 1163412803
pkg syscall (linux-386), const LINUX_REBOOT_CMD_POWER_OFF = 1126301404
pkg syscall (linux-386), const LINUX_REBOOT_CMD_RESTART = 19088743
pkg syscall (linux-386), const LINUX_REBOOT_CMD_RESTART2 = 2712847316
pkg syscall (linux-386), const LINUX_REBOOT_CMD_SW_SUSPEND = 3489725666

	testEndToEnd(t, "loong64", "loong64")
}

func TestPPC64EndToEnd(t *testing.T) {
	defer func(old int) { buildcfg.GOPPC64 = old }(buildcfg.GOPPC64)
	for _, goppc64 := range []int{8, 9, 10} {
		t.Logf("GOPPC64=power%d", goppc64)
		buildcfg.GOPPC64 = goppc64
		// Some pseudo-ops may assemble differently depending on GOPPC64
		testEndToEnd(t, "ppc64", "ppc64")
		testEndToEnd(t, "ppc64", "ppc64_p10")
	}
}