PLBZ 1234(R1), $0, R3                   // 06000000886104d260000000
	// Note, PLD crosses a 64B boundary, and a nop is inserted between PLBZ and PLD
	PLD 1234(R1), $0, R3                    // 04000000e46104d2
	PLFD 1234(R1), $0, F3                   // 06000000c86104d2
	PLFS 1234567890(R4), $0, F3             // 06004996c06402d2
	PLFS 1234567890(R0), $1, F3             // 06104996c06002d2

	"PMXVBF16GER2PN",
	"PMXVBF16GER2NP",
	"PMXVBF16GER2NN",
	"PMXVBF16GER2",
	"PLXVP",
	"PLXV",
	"PLXSSP",
	"PLXSD",
	"PLWZ",
	"PLWA",
	"PLQ",
	"PLHZ",
	"PLHA",
	"PLFS",
	"PLFD",
	"PLD",
	"PLBZ",
	"PADDI",
}

var GenOpcodes = [...]uint32{
	0x7c030162, // AXXSETACCZ
	0x7c010162, // AXXMTACC
	0x7c000162, // AXXMFACC
	0xf0000768, // AXXGENPCVWM

	// because historically we have always returned a descriptor
	// opened in blocking mode. The File will continue to work,
	// but any blocking operation will tie up a thread.
	if f.nonblock {
		f.pfd.SetBlocking()
	}

	return uintptr(f.pfd.Sysfd)
}

// NewFile returns a new File with the given file descriptor and
// name. The returned value will be nil if fd is not a valid file
// descriptor. On Unix systems, if the file descriptor is in

			kind = "pipe"
		}
	}

	f := &File{&file{
		pfd: poll.FD{
			Sysfd:         h,
			IsStream:      true,
			ZeroReadIsEOF: true,
		},
		name: name,
	}}
	runtime.SetFinalizer(f.file, (*file).close)

	// Ignore initialization errors.
	// Assume any problems will show up in later I/O.
	f.pfd.Init(kind, false)

	return f
}

	if err = rc.Control(func(fd uintptr) {
		pfd, network := GetPollFDAndNetwork(server)
		if pfd == nil {
			t.Fatalf("GetPollFDAndNetwork didn't return poll.FD")
		}
		if string(network) != proto {
			t.Fatalf("GetPollFDAndNetwork returned wrong network, got: %s, want: %s", network, proto)
		}
		if pfd.Sysfd != int(fd) {
			t.Fatalf("GetPollFDAndNetwork returned wrong poll.FD, got: %d, want: %d", pfd.Sysfd, int(fd))
		}

	Go asm                       GOPPC64 <= power9          GOPPC64 >= power10
	MOVD mypackage·foo(SB), R3   addis r2, r3, ...          pld r3, ...
	                             ld    r3, r3, ...

	MOVD 131072(R3), R4          addis r31, r4, 2           pld r4, 131072(r3)
	                             ld    r4, 0(R3)

	ADD $131073, R3              lis  r31, 2                paddi r3, r3, 131073

	LHZ: "MOVHZ", LHA: "MOVH", STH: "MOVH",
	LHZU: "MOVHZU", STHU: "MOVHU",
	LWZ: "MOVWZ", LWA: "MOVW", STW: "MOVW",
	LWZU: "MOVWZU", STWU: "MOVWU",
	LD: "MOVD", STD: "MOVD",
	LDU: "MOVDU", STDU: "MOVDU",
	LFD: "FMOVD", STFD: "FMOVD",
	LFS: "FMOVS", STFS: "FMOVS",
	LFDX: "FMOVD", STFDX: "FMOVD",
	LFDU: "FMOVDU", STFDU: "FMOVDU",
	LFDUX: "FMOVDU", STFDUX: "FMOVDU",
	LFSX: "FMOVS", STFSX: "FMOVS",

				default:
					panic(fmt.Sprintf("wrong FP register: %v", inst))
				}
			}
		}
	}

	// Move addressing mode into opcode suffix.
	suffix := ""
	switch inst.Op &^ 15 {
	case PLD, PLI, PLD_W:
		if mem, ok := inst.Args[0].(Mem); ok {
			args[0], suffix = memOpTrans(mem)
		} else {
			panic(fmt.Sprintf("illegal instruction: %v", inst))
		}

		t.Error("internal/poll.SendFile was not called, want it to be")
		return
	}
	if !gotHandled {
		t.Error("internal/poll.SendFile did not handle the write, want it to")
		return
	}
	if &wantConn.(*TCPConn).fd.pfd != gotFD {
		t.Error("internal.poll.SendFile called with unexpected FD")
	}
}

func TestSendfile(t *testing.T) {
	ln := newLocalListener(t, "tcp")
	defer ln.Close()

	errc := make(chan error, 1)

	MOVFW.P	F0, R9             // ERROR "invalid .P suffix"
	MOVWF.W	R3, F1             // ERROR "invalid .W suffix"
	MOVW.S	F0, R9             // ERROR "invalid .S suffix"
	MOVW.U	R3, F1             // ERROR "invalid .U suffix"
	PLD.S	4(R1)              // ERROR "invalid .S suffix"
	CLZ.S	R1, R2             // ERROR "invalid .S suffix"
	MULBB.S	R0, R1, R2         // ERROR "invalid .S suffix"
	MULA.W	R9, R6, R1, g      // ERROR "invalid .W suffix"