FNMADDCC:       "fnmadd.",
	FNMSUB:         "fnmsub",
	FNMSUBCC:       "fnmsub.",
	FRSP:           "frsp",
	FRSPCC:         "frsp.",
	FSUB:           "fsub",
	FSUBCC:         "fsub.",
	ISYNC:          "isync",
	LBZ:            "lbz",
	LBZU:           "lbzu",
	LBZUX:          "lbzux",
	LBZX:           "lbzx",
	LFD:            "lfd",
	LFDU:           "lfdu",
	LFDUX:          "lfdux",

(Add(64|Ptr) ...) => (ADD ...)
(Add(32|16|8) ...) => (ADDW ...)
(Add32F x y) => (Select0 (FADDS x y))
(Add64F x y) => (Select0 (FADD x y))

(Sub(64|Ptr) ...) => (SUB ...)
(Sub(32|16|8) ...) => (SUBW ...)
(Sub32F x y) => (Select0 (FSUBS x y))
(Sub64F x y) => (Select0 (FSUB x y))

(Mul64 ...) => (MULLD ...)
(Mul(32|16|8) ...) => (MULLW ...)
(Mul32F ...) => (FMULS ...)
(Mul64F ...) => (FMUL ...)
(Mul64uhilo ...) => (MLGR ...)

{"Name":"FSUB (vector)","Bits":"0|Q|0|0|1|1|1|0|1|sz|1|Rm:5|1|1|0|1|0|1|Rn:5|Rd:5","Arch":"Vector single-precision and double-precision variant","Syntax":"FSUB <Vd>.<T>, <Vn>.<T>, <Vm>.<T>","Code":"","Alias":""},
{"Name":"FSUB (scalar)","Bits":"0|0|0|1|1|1|1|0|00:2|1|Rm:5|0|0|1|1|1|0|Rn:5|Rd:5","Arch":"Single-precision variant","Syntax":"FSUB <Sd>, <Sn>, <Sm>","Code":"","Alias":""},

	"RDTIME",
	"RDTIMEH",
	"RDINSTRET",
	"RDINSTRETH",
	"FRCSR",
	"FSCSR",
	"FRRM",
	"FSRM",
	"FRFLAGS",
	"FSFLAGS",
	"FSRMI",
	"FSFLAGSI",
	"FLW",
	"FSW",
	"FADDS",
	"FSUBS",
	"FMULS",
	"FDIVS",
	"FMINS",
	"FMAXS",
	"FSQRTS",
	"FMADDS",
	"FMSUBS",
	"FNMADDS",
	"FNMSUBS",
	"FCVTWS",
	"FCVTLS",
	"FCVTSW",
	"FCVTSL",
	"FCVTWUS",
	"FCVTLUS",

(MSUB a (MOVDconst [-1]) x) => (ADD a x)
(MSUB a (MOVDconst [0]) _) => a
(MSUB a (MOVDconst [1]) x) => (SUB a x)
(MSUB a (MOVDconst [c]) x) && isPowerOfTwo64(c) => (SUBshiftLL a x [log64(c)])
(MSUB a (MOVDconst [c]) x) && isPowerOfTwo64(c-1) && c>=3 => (SUB a (ADDshiftLL <x.Type> x x [log64(c-1)]))
(MSUB a (MOVDconst [c]) x) && isPowerOfTwo64(c+1) && c>=7 => (ADD a (SUBshiftLL <x.Type> x x [log64(c+1)]))

	"FRINTMS",
	"FRINTND",
	"FRINTNS",
	"FRINTPD",
	"FRINTPS",
	"FRINTXD",
	"FRINTXS",
	"FRINTZD",
	"FRINTZS",
	"FSQRTD",
	"FSQRTS",
	"FSTPD",
	"FSTPQ",
	"FSTPS",
	"FSUBD",
	"FSUBS",
	"HINT",
	"HLT",
	"HVC",
	"IC",
	"ISB",
	"LDADDAB",
	"LDADDAD",
	"LDADDAH",
	"LDADDALB",
	"LDADDALD",
	"LDADDALH",
	"LDADDALW",
	"LDADDAW",
	"LDADDB",
	"LDADDD",

// and will not run on earlier targets.
//
(Add(Ptr|64|32|16|8) ...) => (ADD ...)
(Add64F ...) => (FADD ...)
(Add32F ...) => (FADDS ...)

(Sub(Ptr|64|32|16|8) ...) => (SUB ...)
(Sub32F ...) => (FSUBS ...)
(Sub64F ...) => (FSUB ...)

(Min(32|64)F x y) && buildcfg.GOPPC64 >= 9 => (XSMINJDP x y)
(Max(32|64)F x y) && buildcfg.GOPPC64 >= 9 => (XSMAXJDP x y)

// Combine 64 bit integer multiply and adds

	//TODO: FSUB F2, F0                     // d8e2
	//TODO: FSUB F3, F0                     // d8e3
	//TODO: FSUBR F0, F2                    // dcea
	//TODO: FSUBR F0, F3                    // dceb
	//TODO: FSUBS (BX)                      // d823
	//TODO: FSUBS (R11)                     // 41d823
	//TODO: FSUBL (BX)                      // dc23
	//TODO: FSUBL (R11)                     // 41dc23

)

// A SubFS is a file system with a Sub method.
type SubFS interface {
	FS

	// Sub returns an FS corresponding to the subtree rooted at dir.
	Sub(dir string) (FS, error)
}

// Sub returns an [FS] corresponding to the subtree rooted at fsys's dir.
//
// If dir is ".", Sub returns fsys unchanged.
// Otherwise, if fs implements [SubFS], Sub returns fsys.Sub(dir).
// Otherwise, Sub returns a new [FS] implementation sub that,

	FMSUBD	F7, F6, F13, F13	// F13 = c = r - t*(P1+t*(P2+t*(P3+t*(P4+t*P5))))
	FMOVD	$2.0, F14
	FSUBD	F13, F14
	FMULD	F6, F13, F15
	FDIVD	F14, F15	// F15 = (r*c)/(2-c)
	FSUBD	F15, F5, F15	// lo-(r*c)/(2-c)
	FSUBD	F4, F15, F15	// (lo-(r*c)/(2-c))-hi
	FSUBD	F15, F1, F16	// F16 = y = 1-((lo-(r*c)/(2-c))-hi)
	// inline Ldexp(y, k), benefit:
	// 1, no parameter pass overhead.