cmd/vendor/golang.org/x/arch: pull updates from x repo

Vendor from golang.org/x/arch (commit f185940).

Implements #19157

Updates #12840
Updates #20762
Updates #20897
Updates #20096
Updates #20766
Updates #20752
Updates #20096
Updates #19142

Change-Id: Idefb8ba2c355dc07f3b9e8dcf5f00173256a0f0f
Reviewed-on: https://go-review.googlesource.com/49530Reviewed-by: Cherry Zhang <cherryyz@google.com>

src/cmd/vendor/golang.org/x/arch/arm/armasm/decode.go

@@ -233,9 +233,9 @@ func decodeArg(aop instArg, x uint32) Arg {
 		typ, count := decodeShift(x)
 		// ROR #0 here means ROR #0, but decodeShift rewrites to RRX #1.
 		if typ == RotateRightExt {
-			return Rm
+			return Reg(Rm)
 		}
-		return RegShift{Rm, typ, count}
+		return RegShift{Rm, typ, uint8(count)}
 
 	case arg_R_shift_R:
 		Rm := Reg(x & (1<<4 - 1))
@@ -247,9 +247,9 @@ func decodeArg(aop instArg, x uint32) Arg {
 		Rm := Reg(x & (1<<4 - 1))
 		typ, count := decodeShift(x)
 		if typ == ShiftLeft && count == 0 {
-			return Rm
+			return Reg(Rm)
 		}
-		return RegShift{Rm, typ, count}
+		return RegShift{Rm, typ, uint8(count)}
 
 	case arg_R1_0:
 		return Reg((x & (1<<4 - 1)))

src/cmd/vendor/golang.org/x/arch/arm/armasm/plan9x.go

@@ -9,6 +9,7 @@ import (
 	"encoding/binary"
 	"fmt"
 	"io"
+	"math"
 	"strings"
 )
 
@@ -37,7 +38,7 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 	op := inst.Op.String()
 
 	switch inst.Op &^ 15 {
-	case LDR_EQ, LDRB_EQ, LDRH_EQ:
+	case LDR_EQ, LDRB_EQ, LDRH_EQ, LDRSB_EQ, LDRSH_EQ, VLDR_EQ:
 		// Check for RET
 		reg, _ := inst.Args[0].(Reg)
 		mem, _ := inst.Args[1].(Mem)
@@ -48,22 +49,22 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 		// Check for PC-relative load.
 		if mem.Base == PC && mem.Sign == 0 && mem.Mode == AddrOffset && text != nil {
 			addr := uint32(pc) + 8 + uint32(mem.Offset)
-			buf := make([]byte, 4)
+			buf := make([]byte, 8)
 			switch inst.Op &^ 15 {
-			case LDRB_EQ:
+			case LDRB_EQ, LDRSB_EQ:
 				if _, err := text.ReadAt(buf[:1], int64(addr)); err != nil {
 					break
 				}
 				args[1] = fmt.Sprintf("$%#x", buf[0])
 
-			case LDRH_EQ:
+			case LDRH_EQ, LDRSH_EQ:
 				if _, err := text.ReadAt(buf[:2], int64(addr)); err != nil {
 					break
 				}
 				args[1] = fmt.Sprintf("$%#x", binary.LittleEndian.Uint16(buf))
 
 			case LDR_EQ:
-				if _, err := text.ReadAt(buf, int64(addr)); err != nil {
+				if _, err := text.ReadAt(buf[:4], int64(addr)); err != nil {
 					break
 				}
 				x := binary.LittleEndian.Uint32(buf)
@@ -72,6 +73,22 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 				} else {
 					args[1] = fmt.Sprintf("$%#x", x)
 				}
+
+			case VLDR_EQ:
+				switch {
+				case strings.HasPrefix(args[0], "D"): // VLDR.F64
+					if _, err := text.ReadAt(buf, int64(addr)); err != nil {
+						break
+					}
+					args[1] = fmt.Sprintf("$%f", math.Float64frombits(binary.LittleEndian.Uint64(buf)))
+				case strings.HasPrefix(args[0], "S"): // VLDR.F32
+					if _, err := text.ReadAt(buf[:4], int64(addr)); err != nil {
+						break
+					}
+					args[1] = fmt.Sprintf("$%f", math.Float32frombits(binary.LittleEndian.Uint32(buf)))
+				default:
+					panic(fmt.Sprintf("wrong FP register: %v", inst))
+				}
 			}
 		}
 	}
@@ -79,7 +96,7 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 	// Move addressing mode into opcode suffix.
 	suffix := ""
 	switch inst.Op &^ 15 {
-	case LDR_EQ, LDRB_EQ, LDRH_EQ, STR_EQ, STRB_EQ, STRH_EQ:
+	case LDR_EQ, LDRB_EQ, LDRSB_EQ, LDRH_EQ, LDRSH_EQ, STR_EQ, STRB_EQ, STRH_EQ, VLDR_EQ, VSTR_EQ:
 		mem, _ := inst.Args[1].(Mem)
 		switch mem.Mode {
 		case AddrOffset, AddrLDM:
@@ -98,7 +115,7 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 		if mem.Sign != 0 {
 			sign := ""
 			if mem.Sign < 0 {
-				sign = ""
+				suffix += ".U"
 			}
 			shift := ""
 			if mem.Count != 0 {
@@ -113,6 +130,11 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 	for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 {
 		args[i], args[j] = args[j], args[i]
 	}
+	// For MLA-like instructions, the addend is the third operand.
+	switch inst.Op &^ 15 {
+	case SMLAWT_EQ, SMLAWB_EQ, MLA_EQ, MLA_S_EQ, MLS_EQ, SMMLA_EQ, SMMLS_EQ, SMLABB_EQ, SMLATB_EQ, SMLABT_EQ, SMLATT_EQ, SMLAD_EQ, SMLAD_X_EQ, SMLSD_EQ, SMLSD_X_EQ:
+		args = []string{args[1], args[2], args[0], args[3]}
+	}
 
 	switch inst.Op &^ 15 {
 	case MOV_EQ:
@@ -121,9 +143,26 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 	case LDR_EQ:
 		op = "MOVW" + op[3:] + suffix
 	case LDRB_EQ:
-		op = "MOVB" + op[4:] + suffix
+		op = "MOVBU" + op[4:] + suffix
+	case LDRSB_EQ:
+		op = "MOVBS" + op[5:] + suffix
 	case LDRH_EQ:
-		op = "MOVH" + op[4:] + suffix
+		op = "MOVHU" + op[4:] + suffix
+	case LDRSH_EQ:
+		op = "MOVHS" + op[5:] + suffix
+	case VLDR_EQ:
+		switch {
+		case strings.HasPrefix(args[1], "D"): // VLDR.F64
+			op = "MOVD" + op[4:] + suffix
+			args[1] = "F" + args[1][1:] // Dx -> Fx
+		case strings.HasPrefix(args[1], "S"): // VLDR.F32
+			op = "MOVF" + op[4:] + suffix
+			if inst.Args[0].(Reg)&1 == 0 { // Sx -> Fy, y = x/2, if x is even
+				args[1] = fmt.Sprintf("F%d", (inst.Args[0].(Reg)-S0)/2)
+			}
+		default:
+			panic(fmt.Sprintf("wrong FP register: %v", inst))
+		}
 
 	case STR_EQ:
 		op = "MOVW" + op[3:] + suffix
@@ -134,6 +173,20 @@ func GoSyntax(inst Inst, pc uint64, symname func(uint64) (string, uint64), text
 	case STRH_EQ:
 		op = "MOVH" + op[4:] + suffix
 		args[0], args[1] = args[1], args[0]
+	case VSTR_EQ:
+		switch {
+		case strings.HasPrefix(args[1], "D"): // VSTR.F64
+			op = "MOVD" + op[4:] + suffix
+			args[1] = "F" + args[1][1:] // Dx -> Fx
+		case strings.HasPrefix(args[1], "S"): // VSTR.F32
+			op = "MOVF" + op[4:] + suffix
+			if inst.Args[0].(Reg)&1 == 0 { // Sx -> Fy, y = x/2, if x is even
+				args[1] = fmt.Sprintf("F%d", (inst.Args[0].(Reg)-S0)/2)
+			}
+		default:
+			panic(fmt.Sprintf("wrong FP register: %v", inst))
+		}
+		args[0], args[1] = args[1], args[0]
 	}
 
 	if args != nil {
@@ -154,7 +207,7 @@ func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg
 	case Endian:
 
 	case Imm:
-		return fmt.Sprintf("$%d", int(a))
+		return fmt.Sprintf("$%d", uint32(a))
 
 	case Mem:
 
@@ -185,6 +238,8 @@ func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg
 				} else {
 					fmt.Fprintf(&buf, "R%d-R%d", start, end)
 				}
+				start = -2
+				end = -2
 			}
 		}
 		for i := 0; i < 16; i++ {
@@ -195,6 +250,8 @@ func plan9Arg(inst *Inst, pc uint64, symname func(uint64) (string, uint64), arg
 				}
 				start = i
 				end = i
+			} else {
+				flush()
 			}
 		}
 		flush()

src/cmd/vendor/golang.org/x/arch/arm/armasm/tables.go

@@ -945,6 +945,22 @@ const (
 	MRS_LE
 	MRS
 	MRS_ZZ
+	MSR_EQ
+	MSR_NE
+	MSR_CS
+	MSR_CC
+	MSR_MI
+	MSR_PL
+	MSR_VS
+	MSR_VC
+	MSR_HI
+	MSR_LS
+	MSR_GE
+	MSR_LT
+	MSR_GT
+	MSR_LE
+	MSR
+	MSR_ZZ
 	MUL_EQ
 	MUL_NE
 	MUL_CS
@@ -1585,6 +1601,22 @@ const (
 	SBFX_LE
 	SBFX
 	SBFX_ZZ
+	SDIV_EQ
+	SDIV_NE
+	SDIV_CS
+	SDIV_CC
+	SDIV_MI
+	SDIV_PL
+	SDIV_VS
+	SDIV_VC
+	SDIV_HI
+	SDIV_LS
+	SDIV_GE
+	SDIV_LT
+	SDIV_GT
+	SDIV_LE
+	SDIV
+	SDIV_ZZ
 	SEL_EQ
 	SEL_NE
 	SEL_CS
@@ -2929,6 +2961,22 @@ const (
 	UBFX_LE
 	UBFX
 	UBFX_ZZ
+	UDIV_EQ
+	UDIV_NE
+	UDIV_CS
+	UDIV_CC
+	UDIV_MI
+	UDIV_PL
+	UDIV_VS
+	UDIV_VC
+	UDIV_HI
+	UDIV_LS
+	UDIV_GE
+	UDIV_LT
+	UDIV_GT
+	UDIV_LE
+	UDIV
+	UDIV_ZZ
 	UHADD16_EQ
 	UHADD16_NE
 	UHADD16_CS
@@ -5480,6 +5528,22 @@ var opstr = [...]string{
 	MRS_LE:            "MRS.LE",
 	MRS:               "MRS",
 	MRS_ZZ:            "MRS.ZZ",
+	MSR_EQ:            "MSR.EQ",
+	MSR_NE:            "MSR.NE",
+	MSR_CS:            "MSR.CS",
+	MSR_CC:            "MSR.CC",
+	MSR_MI:            "MSR.MI",
+	MSR_PL:            "MSR.PL",
+	MSR_VS:            "MSR.VS",
+	MSR_VC:            "MSR.VC",
+	MSR_HI:            "MSR.HI",
+	MSR_LS:            "MSR.LS",
+	MSR_GE:            "MSR.GE",
+	MSR_LT:            "MSR.LT",
+	MSR_GT:            "MSR.GT",
+	MSR_LE:            "MSR.LE",
+	MSR:               "MSR",
+	MSR_ZZ:            "MSR.ZZ",
 	MUL_EQ:            "MUL.EQ",
 	MUL_NE:            "MUL.NE",
 	MUL_CS:            "MUL.CS",
@@ -6107,6 +6171,22 @@ var opstr = [...]string{
 	SBFX_LE:           "SBFX.LE",
 	SBFX:              "SBFX",
 	SBFX_ZZ:           "SBFX.ZZ",
+	SDIV_EQ:           "SDIV.EQ",
+	SDIV_NE:           "SDIV.NE",
+	SDIV_CS:           "SDIV.CS",
+	SDIV_CC:           "SDIV.CC",
+	SDIV_MI:           "SDIV.MI",
+	SDIV_PL:           "SDIV.PL",
+	SDIV_VS:           "SDIV.VS",
+	SDIV_VC:           "SDIV.VC",
+	SDIV_HI:           "SDIV.HI",
+	SDIV_LS:           "SDIV.LS",
+	SDIV_GE:           "SDIV.GE",
+	SDIV_LT:           "SDIV.LT",
+	SDIV_GT:           "SDIV.GT",
+	SDIV_LE:           "SDIV.LE",
+	SDIV:              "SDIV",
+	SDIV_ZZ:           "SDIV.ZZ",
 	SEL_EQ:            "SEL.EQ",
 	SEL_NE:            "SEL.NE",
 	SEL_CS:            "SEL.CS",
@@ -7436,6 +7516,22 @@ var opstr = [...]string{
 	UBFX_LE:           "UBFX.LE",
 	UBFX:              "UBFX",
 	UBFX_ZZ:           "UBFX.ZZ",
+	UDIV_EQ:           "UDIV.EQ",
+	UDIV_NE:           "UDIV.NE",
+	UDIV_CS:           "UDIV.CS",
+	UDIV_CC:           "UDIV.CC",
+	UDIV_MI:           "UDIV.MI",
+	UDIV_PL:           "UDIV.PL",
+	UDIV_VS:           "UDIV.VS",
+	UDIV_VC:           "UDIV.VC",
+	UDIV_HI:           "UDIV.HI",
+	UDIV_LS:           "UDIV.LS",
+	UDIV_GE:           "UDIV.GE",
+	UDIV_LT:           "UDIV.LT",
+	UDIV_GT:           "UDIV.GT",
+	UDIV_LE:           "UDIV.LE",
+	UDIV:              "UDIV",
+	UDIV_ZZ:           "UDIV.ZZ",
 	UHADD16_EQ:        "UHADD16.EQ",
 	UHADD16_NE:        "UHADD16.NE",
 	UHADD16_CS:        "UHADD16.CS",
@@ -9194,6 +9290,10 @@ var instFormats = [...]instFormat{
 	{0x0fef0ff0, 0x01a00000, 2, MOV_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_0}},                                  // MOV{S}<c> <Rd>,<Rm> cond:4|0|0|0|1|1|0|1|S|0|0|0|0|Rd:4|0|0|0|0|0|0|0|0|Rm:4
 	{0x0fff0fff, 0x010f0000, 4, MRS_EQ, 0x1c04, instArgs{arg_R_12, arg_APSR}},                                     // MRS<c> <Rd>,APSR cond:4|0|0|0|1|0|0|0|0|(1)|(1)|(1)|(1)|Rd:4|(0)|(0)|(0)|(0)|0|0|0|0|(0)|(0)|(0)|(0)
 	{0x0ff000f0, 0x010f0000, 3, MRS_EQ, 0x1c04, instArgs{arg_R_12, arg_APSR}},                                     // MRS<c> <Rd>,APSR cond:4|0|0|0|1|0|0|0|0|(1)|(1)|(1)|(1)|Rd:4|(0)|(0)|(0)|(0)|0|0|0|0|(0)|(0)|(0)|(0)
+	{0x0ffffff0, 0x012cf000, 4, MSR_EQ, 0x1c04, instArgs{arg_APSR, arg_R_0}},                                      // MSR<c> APSR,<Rn> cond:4|0|0|0|1|0|0|1|0|1|1|0|0|(1)|(1)|(1)|(1)|(0)|(0)|(0)|(0)|0|0|0|0|Rn:4
+	{0x0fff00f0, 0x012cf000, 3, MSR_EQ, 0x1c04, instArgs{arg_APSR, arg_R_0}},                                      // MSR<c> APSR,<Rn> cond:4|0|0|0|1|0|0|1|0|1|1|0|0|(1)|(1)|(1)|(1)|(0)|(0)|(0)|(0)|0|0|0|0|Rn:4
+	{0x0ffff000, 0x032cf000, 4, MSR_EQ, 0x1c04, instArgs{arg_APSR, arg_const}},                                    // MSR<c> APSR,#<const> cond:4|0|0|1|1|0|0|1|0|1|1|0|0|(1)|(1)|(1)|(1)|imm12:12
+	{0x0fff0000, 0x032cf000, 3, MSR_EQ, 0x1c04, instArgs{arg_APSR, arg_const}},                                    // MSR<c> APSR,#<const> cond:4|0|0|1|1|0|0|1|0|1|1|0|0|(1)|(1)|(1)|(1)|imm12:12
 	{0x0fe0f0f0, 0x00000090, 4, MUL_EQ, 0x14011c04, instArgs{arg_R_16, arg_R_0, arg_R_8}},                         // MUL{S}<c> <Rd>,<Rn>,<Rm> cond:4|0|0|0|0|0|0|0|S|Rd:4|(0)|(0)|(0)|(0)|Rm:4|1|0|0|1|Rn:4
 	{0x0fe000f0, 0x00000090, 3, MUL_EQ, 0x14011c04, instArgs{arg_R_16, arg_R_0, arg_R_8}},                         // MUL{S}<c> <Rd>,<Rn>,<Rm> cond:4|0|0|0|0|0|0|0|S|Rd:4|(0)|(0)|(0)|(0)|Rm:4|1|0|0|1|Rn:4
 	{0x0fef0000, 0x03e00000, 2, MVN_EQ, 0x14011c04, instArgs{arg_R_12, arg_const}},                                // MVN{S}<c> <Rd>,#<const> cond:4|0|0|1|1|1|1|1|S|(0)|(0)|(0)|(0)|Rd:4|imm12:12
@@ -9267,6 +9367,8 @@ var instFormats = [...]instFormat{
 	{0x0fe00090, 0x00c00010, 4, SBC_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_R}},                  // SBC{S}<c> <Rd>,<Rn>,<Rm>,<type> <Rs> cond:4|0|0|0|0|1|1|0|S|Rn:4|Rd:4|Rs:4|0|type:2|1|Rm:4
 	{0x0fe00010, 0x00c00000, 2, SBC_EQ, 0x14011c04, instArgs{arg_R_12, arg_R_16, arg_R_shift_imm}},                // SBC{S}<c> <Rd>,<Rn>,<Rm>{,<shift>} cond:4|0|0|0|0|1|1|0|S|Rn:4|Rd:4|imm5:5|type:2|0|Rm:4
 	{0x0fe00070, 0x07a00050, 4, SBFX_EQ, 0x1c04, instArgs{arg_R_12, arg_R_0, arg_imm5, arg_widthm1}},              // SBFX<c> <Rd>,<Rn>,#<lsb>,#<widthm1> cond:4|0|1|1|1|1|0|1|widthm1:5|Rd:4|lsb:5|1|0|1|Rn:4
+	{0x0ff0f0f0, 0x0710f010, 4, SDIV_EQ, 0x1c04, instArgs{arg_R_16, arg_R_0, arg_R_8}},                            // SDIV<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|1|0|0|0|1|Rd:4|(1)|(1)|(1)|(1)|Rm:4|0|0|0|1|Rn:4
+	{0x0ff000f0, 0x0710f010, 3, SDIV_EQ, 0x1c04, instArgs{arg_R_16, arg_R_0, arg_R_8}},                            // SDIV<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|1|0|0|0|1|Rd:4|(1)|(1)|(1)|(1)|Rm:4|0|0|0|1|Rn:4
 	{0x0ff00ff0, 0x06800fb0, 4, SEL_EQ, 0x1c04, instArgs{arg_R_12, arg_R_16, arg_R_0}},                            // SEL<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|0|1|0|0|0|Rn:4|Rd:4|(1)|(1)|(1)|(1)|1|0|1|1|Rm:4
 	{0x0ff000f0, 0x06800fb0, 3, SEL_EQ, 0x1c04, instArgs{arg_R_12, arg_R_16, arg_R_0}},                            // SEL<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|0|1|0|0|0|Rn:4|Rd:4|(1)|(1)|(1)|(1)|1|0|1|1|Rm:4
 	{0xfffffdff, 0xf1010000, 4, SETEND, 0x0, instArgs{arg_endian}},                                                // SETEND <endian_specifier> 1|1|1|1|0|0|0|1|0|0|0|0|0|0|0|1|0|0|0|0|0|0|E|(0)|(0)|(0)|(0)|(0)|(0)|(0)|(0)|(0)
@@ -9365,6 +9467,8 @@ var instFormats = [...]instFormat{
 	{0x0ff00ff0, 0x06500f30, 4, UASX_EQ, 0x1c04, instArgs{arg_R_12, arg_R_16, arg_R_0}},                           // UASX<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|0|0|1|0|1|Rn:4|Rd:4|(1)|(1)|(1)|(1)|0|0|1|1|Rm:4
 	{0x0ff000f0, 0x06500f30, 3, UASX_EQ, 0x1c04, instArgs{arg_R_12, arg_R_16, arg_R_0}},                           // UASX<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|0|0|1|0|1|Rn:4|Rd:4|(1)|(1)|(1)|(1)|0|0|1|1|Rm:4
 	{0x0fe00070, 0x07e00050, 4, UBFX_EQ, 0x1c04, instArgs{arg_R_12, arg_R_0, arg_imm5, arg_widthm1}},              // UBFX<c> <Rd>,<Rn>,#<lsb>,#<widthm1> cond:4|0|1|1|1|1|1|1|widthm1:5|Rd:4|lsb:5|1|0|1|Rn:4
+	{0x0ff0f0f0, 0x0730f010, 4, UDIV_EQ, 0x1c04, instArgs{arg_R_16, arg_R_0, arg_R_8}},                            // UDIV<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|1|0|0|1|1|Rd:4|(1)|(1)|(1)|(1)|Rm:4|0|0|0|1|Rn:4
+	{0x0ff000f0, 0x0730f010, 3, UDIV_EQ, 0x1c04, instArgs{arg_R_16, arg_R_0, arg_R_8}},                            // UDIV<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|1|0|0|1|1|Rd:4|(1)|(1)|(1)|(1)|Rm:4|0|0|0|1|Rn:4
 	{0x0ff00ff0, 0x06700f10, 4, UHADD16_EQ, 0x1c04, instArgs{arg_R_12, arg_R_16, arg_R_0}},                        // UHADD16<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|0|0|1|1|1|Rn:4|Rd:4|(1)|(1)|(1)|(1)|0|0|0|1|Rm:4
 	{0x0ff000f0, 0x06700f10, 3, UHADD16_EQ, 0x1c04, instArgs{arg_R_12, arg_R_16, arg_R_0}},                        // UHADD16<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|0|0|1|1|1|Rn:4|Rd:4|(1)|(1)|(1)|(1)|0|0|0|1|Rm:4
 	{0x0ff00ff0, 0x06700f90, 4, UHADD8_EQ, 0x1c04, instArgs{arg_R_12, arg_R_16, arg_R_0}},                         // UHADD8<c> <Rd>,<Rn>,<Rm> cond:4|0|1|1|0|0|1|1|1|Rn:4|Rd:4|(1)|(1)|(1)|(1)|1|0|0|1|Rm:4

src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/condition.go

+// Generated by ARM internal tool
+// DO NOT EDIT
+
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package arm64asm
+
+// Following functions are used as the predicator: canDecode of according instruction
+// Refer to instFormat inside decode.go for more details
+
+func at_sys_cr_system_cond(instr uint32) bool {
+	return sys_op_4((instr>>16)&0x7, 0x7, 0x8, (instr>>5)&0x7) == Sys_AT
+}
+
+func bfi_bfm_32m_bitfield_cond(instr uint32) bool {
+	return (instr>>5)&0x1f != 0x1f && uint8((instr>>10)&0x3f) < uint8((instr>>16)&0x3f)
+}
+
+func bfi_bfm_64m_bitfield_cond(instr uint32) bool {
+	return (instr>>5)&0x1f != 0x1f && uint8((instr>>10)&0x3f) < uint8((instr>>16)&0x3f)
+}
+
+func bfxil_bfm_32m_bitfield_cond(instr uint32) bool {
+	return uint8((instr>>10)&0x3f) >= uint8((instr>>16)&0x3f)
+}
+
+func bfxil_bfm_64m_bitfield_cond(instr uint32) bool {
+	return uint8((instr>>10)&0x3f) >= uint8((instr>>16)&0x3f)
+}
+
+func cinc_csinc_32_condsel_cond(instr uint32) bool {
+	return instr&0x1f0000 != 0x1f0000 && instr&0xe000 != 0xe000 && instr&0x3e0 != 0x3e0 && (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func cinc_csinc_64_condsel_cond(instr uint32) bool {
+	return instr&0x1f0000 != 0x1f0000 && instr&0xe000 != 0xe000 && instr&0x3e0 != 0x3e0 && (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func cinv_csinv_32_condsel_cond(instr uint32) bool {
+	return instr&0x1f0000 != 0x1f0000 && instr&0xe000 != 0xe000 && instr&0x3e0 != 0x3e0 && (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func cinv_csinv_64_condsel_cond(instr uint32) bool {
+	return instr&0x1f0000 != 0x1f0000 && instr&0xe000 != 0xe000 && instr&0x3e0 != 0x3e0 && (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func cneg_csneg_32_condsel_cond(instr uint32) bool {
+	return instr&0xe000 != 0xe000 && (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func cneg_csneg_64_condsel_cond(instr uint32) bool {
+	return instr&0xe000 != 0xe000 && (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func csinc_general_cond(instr uint32) bool {
+	return instr&0xe000 != 0xe000
+}
+func csinv_general_cond(instr uint32) bool {
+	return instr&0xe000 != 0xe000
+}
+func dc_sys_cr_system_cond(instr uint32) bool {
+	return sys_op_4((instr>>16)&0x7, 0x7, (instr>>8)&0xf, (instr>>5)&0x7) == Sys_DC
+}
+
+func ic_sys_cr_system_cond(instr uint32) bool {
+	return sys_op_4((instr>>16)&0x7, 0x7, (instr>>8)&0xf, (instr>>5)&0x7) == Sys_IC
+}
+
+func lsl_ubfm_32m_bitfield_cond(instr uint32) bool {
+	return instr&0xfc00 != 0x7c00 && (instr>>10)&0x3f+1 == (instr>>16)&0x3f
+}
+
+func lsl_ubfm_64m_bitfield_cond(instr uint32) bool {
+	return instr&0xfc00 != 0xfc00 && (instr>>10)&0x3f+1 == (instr>>16)&0x3f
+}
+
+func mov_orr_32_log_imm_cond(instr uint32) bool {
+	return !move_wide_preferred_4((instr>>31)&0x1, (instr>>22)&0x1, (instr>>10)&0x3f, (instr>>16)&0x3f)
+}
+
+func mov_orr_64_log_imm_cond(instr uint32) bool {
+	return !move_wide_preferred_4((instr>>31)&0x1, (instr>>22)&0x1, (instr>>10)&0x3f, (instr>>16)&0x3f)
+}
+
+func mov_movn_32_movewide_cond(instr uint32) bool {
+	return !(is_zero((instr>>5)&0xffff) && (instr>>21)&0x3 != 0x0) && !is_ones_n16((instr>>5)&0xffff)
+}
+
+func mov_movn_64_movewide_cond(instr uint32) bool {
+	return !(is_zero((instr>>5)&0xffff) && (instr>>21)&0x3 != 0x0)
+}
+
+func mov_add_32_addsub_imm_cond(instr uint32) bool {
+	return instr&0x1f == 0x1f || (instr>>5)&0x1f == 0x1f
+}
+
+func mov_add_64_addsub_imm_cond(instr uint32) bool {
+	return instr&0x1f == 0x1f || (instr>>5)&0x1f == 0x1f
+}
+
+func mov_movz_32_movewide_cond(instr uint32) bool {
+	return !(is_zero((instr>>5)&0xffff) && (instr>>21)&0x3 != 0x0)
+}
+
+func mov_movz_64_movewide_cond(instr uint32) bool {
+	return !(is_zero((instr>>5)&0xffff) && (instr>>21)&0x3 != 0x0)
+}
+
+func ror_extr_32_extract_cond(instr uint32) bool {
+	return (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func ror_extr_64_extract_cond(instr uint32) bool {
+	return (instr>>5)&0x1f == (instr>>16)&0x1f
+}
+
+func sbfiz_sbfm_32m_bitfield_cond(instr uint32) bool {
+	return uint8((instr>>10)&0x3f) < uint8((instr>>16)&0x3f)
+}
+
+func sbfiz_sbfm_64m_bitfield_cond(instr uint32) bool {
+	return uint8((instr>>10)&0x3f) < uint8((instr>>16)&0x3f)
+}
+
+func sbfx_sbfm_32m_bitfield_cond(instr uint32) bool {
+	return bfxpreferred_4((instr>>31)&0x1, extract_bit((instr>>29)&0x3, 1), (instr>>10)&0x3f, (instr>>16)&0x3f)
+}
+
+func sbfx_sbfm_64m_bitfield_cond(instr uint32) bool {
+	return bfxpreferred_4((instr>>31)&0x1, extract_bit((instr>>29)&0x3, 1), (instr>>10)&0x3f, (instr>>16)&0x3f)
+}
+
+func tlbi_sys_cr_system_cond(instr uint32) bool {
+	return sys_op_4((instr>>16)&0x7, 0x8, (instr>>8)&0xf, (instr>>5)&0x7) == Sys_TLBI
+}
+
+func ubfiz_ubfm_32m_bitfield_cond(instr uint32) bool {
+	return uint8((instr>>10)&0x3f) < uint8((instr>>16)&0x3f)
+}
+
+func ubfiz_ubfm_64m_bitfield_cond(instr uint32) bool {
+	return uint8((instr>>10)&0x3f) < uint8((instr>>16)&0x3f)
+}
+
+func ubfx_ubfm_32m_bitfield_cond(instr uint32) bool {
+	return bfxpreferred_4((instr>>31)&0x1, extract_bit((instr>>29)&0x3, 1), (instr>>10)&0x3f, (instr>>16)&0x3f)
+}
+
+func ubfx_ubfm_64m_bitfield_cond(instr uint32) bool {
+	return bfxpreferred_4((instr>>31)&0x1, extract_bit((instr>>29)&0x3, 1), (instr>>10)&0x3f, (instr>>16)&0x3f)
+}
+
+func fcvtzs_asisdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func fcvtzs_asimdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func fcvtzu_asisdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func fcvtzu_asimdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func mov_umov_asimdins_w_w_cond(instr uint32) bool {
+	return ((instr>>16)&0x1f)&0x7 == 0x4
+}
+
+func mov_umov_asimdins_x_x_cond(instr uint32) bool {
+	return ((instr>>16)&0x1f)&0xf == 0x8
+}
+
+func mov_orr_asimdsame_only_cond(instr uint32) bool {
+	return (instr>>16)&0x1f == (instr>>5)&0x1f
+}
+
+func rshrn_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func scvtf_asisdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func scvtf_asimdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func shl_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func shl_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func shrn_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sli_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sli_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqrshrn_asisdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqrshrn_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqrshrun_asisdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqrshrun_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshl_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshl_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshlu_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshlu_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshrn_asisdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshrn_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshrun_asisdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sqshrun_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sri_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sri_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func srshr_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func srshr_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func srsra_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func srsra_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sshll_asimdshf_l_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sshr_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sshr_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ssra_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ssra_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func sxtl_sshll_asimdshf_l_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0 && bit_count((instr>>19)&0xf) == 1
+}
+
+func ucvtf_asisdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ucvtf_asimdshf_c_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func uqrshrn_asisdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func uqrshrn_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func uqshl_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func uqshl_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func uqshrn_asisdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func uqshrn_asimdshf_n_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func urshr_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func urshr_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ursra_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ursra_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ushll_asimdshf_l_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ushr_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func ushr_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func usra_asisdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func usra_asimdshf_r_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0
+}
+func uxtl_ushll_asimdshf_l_cond(instr uint32) bool {
+	return instr&0x780000 != 0x0 && bit_count((instr>>19)&0xf) == 1
+}

src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/condition_util.go

+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package arm64asm
+
+func extract_bit(value, bit uint32) uint32 {
+	return (value >> bit) & 1
+}
+
+func bfxpreferred_4(sf, opc1, imms, immr uint32) bool {
+	if imms < immr {
+		return false
+	}
+	if (imms>>5 == sf) && (imms&0x1f == 0x1f) {
+		return false
+	}
+	if immr == 0 {
+		if sf == 0 && (imms == 7 || imms == 15) {
+			return false
+		}
+		if sf == 1 && opc1 == 0 && (imms == 7 ||
+			imms == 15 || imms == 31) {
+			return false
+		}
+	}
+	return true
+}
+
+func move_wide_preferred_4(sf, N, imms, immr uint32) bool {
+	if sf == 1 && N != 1 {
+		return false
+	}
+	if sf == 0 && !(N == 0 && ((imms>>5)&1) == 0) {
+		return false
+	}
+	if imms < 16 {
+		return (-immr)%16 <= (15 - imms)
+	}
+	width := uint32(32)
+	if sf == 1 {
+		width = uint32(64)
+	}
+	if imms >= (width - 15) {
+		return (immr % 16) <= (imms - (width - 15))
+	}
+	return false
+}
+
+type Sys uint8
+
+const (
+	Sys_AT Sys = iota
+	Sys_DC
+	Sys_IC
+	Sys_TLBI
+	Sys_SYS
+)
+
+func sys_op_4(op1, crn, crm, op2 uint32) Sys {
+	// TODO: system instruction
+	return Sys_SYS
+}
+
+func is_zero(x uint32) bool {
+	return x == 0
+}
+
+func is_ones_n16(x uint32) bool {
+	return x == 0xffff
+}
+
+func bit_count(x uint32) uint8 {
+	var count uint8
+	for count = 0; x > 0; x >>= 1 {
+		if (x & 1) == 1 {
+			count++
+		}
+	}
+	return count
+}

src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/decode_test.go

+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package arm64asm
+
+import (
+	"encoding/hex"
+	"io/ioutil"
+	"strings"
+	"testing"
+)
+
+func TestDecode(t *testing.T) {
+	data, err := ioutil.ReadFile("testdata/cases.txt")
+	if err != nil {
+		t.Fatal(err)
+	}
+	all := string(data)
+	for strings.Contains(all, "\t\t") {
+		all = strings.Replace(all, "\t\t", "\t", -1)
+	}
+	for _, line := range strings.Split(all, "\n") {
+		line = strings.TrimSpace(line)
+		if line == "" || strings.HasPrefix(line, "#") {
+			continue
+		}
+		f := strings.SplitN(line, "\t", 3)
+		i := strings.Index(f[0], "|")
+		if i < 0 {
+			t.Errorf("parsing %q: missing | separator", f[0])
+			continue
+		}
+		if i%2 != 0 {
+			t.Errorf("parsing %q: misaligned | separator", f[0])
+		}
+		code, err := hex.DecodeString(f[0][:i] + f[0][i+1:])
+		if err != nil {
+			t.Errorf("parsing %q: %v", f[0], err)
+			continue
+		}
+		syntax, asm := f[1], f[2]
+		inst, decodeErr := Decode(code)
+		if decodeErr != nil && decodeErr != errUnknown {
+			// Some rarely used system instructions are not supported
+			// Following logicals will filter such unknown instructions
+
+			t.Errorf("parsing %x: %s", code, decodeErr)
+			continue
+		}
+		var out string
+		switch syntax {
+		case "gnu":
+			out = GNUSyntax(inst)
+		case "plan9":
+			out = GoSyntax(inst, 0, nil, nil)
+		default:
+			t.Errorf("unknown syntax %q", syntax)
+			continue
+		}
+		// TODO: system instruction.
+		var Todo = strings.Fields(`
+			sys
+			dc
+			at
+			tlbi
+			ic
+			hvc
+			smc
+		`)
+		if strings.Replace(out, " ", "", -1) != strings.Replace(asm, " ", "", -1) && !hasPrefix(asm, Todo...) {
+			// Exclude MSR since GNU objdump result is incorrect. eg. 0xd504431f msr s0_4_c4_c3_0, xzr
+			if !strings.HasSuffix(asm, " nv") && !strings.HasPrefix(asm, "msr") {
+				t.Errorf("Decode(%s) [%s] = %s, want %s", f[0], syntax, out, asm)
+			}
+		}
+	}
+}

src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/gnu.go

+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package arm64asm
+
+import (
+	"strings"
+)
+
+// GNUSyntax returns the GNU assembler syntax for the instruction, as defined by GNU binutils.
+// This form typically matches the syntax defined in the ARM Reference Manual.
+func GNUSyntax(inst Inst) string {
+	switch inst.Op {
+	case RET:
+		if r, ok := inst.Args[0].(Reg); ok && r == X30 {
+			return "ret"
+		}
+	case B:
+		if _, ok := inst.Args[0].(Cond); ok {
+			return strings.ToLower("b." + inst.Args[0].String() + " " + inst.Args[1].String())
+		}
+	case SYSL:
+		result := strings.ToLower(inst.String())
+		return strings.Replace(result, "c", "C", -1)
+	case DCPS1, DCPS2, DCPS3, CLREX:
+		return strings.ToLower(strings.TrimSpace(inst.String()))
+	case ISB:
+		if strings.Contains(inst.String(), "SY") {
+			result := strings.TrimSuffix(inst.String(), " SY")
+			return strings.ToLower(result)
+		}
+	}
+	return strings.ToLower(inst.String())
+}

src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/objdump_test.go

+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package arm64asm
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestObjdumpARM64Testdata(t *testing.T) { testObjdumpARM64(t, testdataCases(t)) }
+func TestObjdumpARM64Manual(t *testing.T)   { testObjdumpARM64(t, hexCases(t, objdumpManualTests)) }
+func TestObjdumpARM64Cond(t *testing.T)     { testObjdumpARM64(t, condCases(t)) }
+func TestObjdumpARM64(t *testing.T)       { testObjdumpARM64(t, JSONCases(t)) }
+
+// objdumpManualTests holds test cases that will be run by TestObjdumpARMManual.
+// If you are debugging a few cases that turned up in a longer run, it can be useful
+// to list them here and then use -run=Manual, particularly with tracing enabled.
+// Note that these are byte sequences, so they must be reversed from the usual
+// word presentation.
+var objdumpManualTests = `
+bf2003d5
+9f2003d5
+7f2003d5
+5f2003d5
+3f2003d5
+1f2003d5
+df4d03d5
+ff4d03d5
+28d91b14
+da6cb530
+15e5e514
+ff4603d5
+df4803d5
+bf4100d5
+9f3f03d5
+9f3e03d5
+9f3d03d5
+9f3b03d5
+9f3a03d5
+9f3903d5
+9f3703d5
+9f3603d5
+9f3503d5
+9f3303d5
+9f3203d5
+9f3103d5
+ff4603d5
+df4803d5
+bf4100d5
+a3681b53
+47dc78d3
+0500a012
+0500e092
+0500a052
+0500a0d2
+cd5a206e
+cd5a202e
+743d050e
+743d0a0e
+743d0c0e
+743d084e
+`
+
+// allowedMismatchObjdump reports whether the mismatch between text and dec
+// should be allowed by the test.
+func allowedMismatchObjdump(text string, inst *Inst, dec ExtInst) bool {
+	// Skip unsupported instructions
+	if hasPrefix(dec.text, todo...) {
+		return true
+	}
+	// GNU objdump has incorrect alias conditions for following instructions
+	if inst.Enc&0x000003ff == 0x000003ff && hasPrefix(dec.text, "negs") && hasPrefix(text, "cmp") {
+		return true
+	}
+	// GNU objdump "NV" is equal to our "AL"
+	if strings.HasSuffix(dec.text, " nv") && strings.HasSuffix(text, " al") {
+		return true
+	}
+	if strings.HasPrefix(dec.text, "b.nv") && strings.HasPrefix(text, "b.al") {
+		return true
+	}
+	// GNU objdump recognizes invalid binaries as following instructions
+	if hasPrefix(dec.text, "hint", "mrs", "msr", "bfc", "orr", "mov") {
+		return true
+	}
+	if strings.HasPrefix(text, "hint") {
+		return true
+	}
+	// GNU objdump recognizes reserved valuse as valid ones
+	if strings.Contains(text, "unknown instruction") && hasPrefix(dec.text, "fmla", "fmul", "fmulx", "fcvtzs", "fcvtzu", "fmls", "fmov", "scvtf", "ucvtf") {
+		return true
+	}
+	// GNU objdump misses spaces between operands for some instructions (e.g., "ld1 {v10.2s, v11.2s}, [x23],#16")
+	if strings.Replace(text, " ", "", -1) == strings.Replace(dec.text, " ", "", -1) {
+		return true
+	}
+	return false
+}
+
+// TODO: system instruction.
+var todo = strings.Fields(`
+	sys
+	dc
+	at
+	tlbi
+	ic
+	hvc
+	smc
+`)
+
+// Following instructions can't be covered because they are just aliases to another instructions which are always preferred
+var Ncover = strings.Fields(`
+	sbfm
+	asrv
+	bfm
+	ubfm
+	lslv
+	lsrv
+	rorv
+	ins
+	dup
+`)

src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/objdumpext_test.go

+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Copied and simplified from ../../arm/armasm/objdumpext_test.go.
+
+package arm64asm
+
+import (
+	"bytes"
+	"debug/elf"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+const objdumpPath = "/usr/bin/objdump"
+
+func testObjdumpARM64(t *testing.T, generate func(func([]byte))) {
+	testObjdumpArch(t, generate, ModeARM64)
+}
+
+func testObjdumpArch(t *testing.T, generate func(func([]byte)), arch Mode) {
+	if _, err := os.Stat(objdumpPath); err != nil {
+		t.Skip(err)
+	}
+	// Check objdump can disassemble elf64-aarch64.
+	if test := objdumpinfo(); test == false {
+		t.Skip("Skip the test if installed objdump doesn't support aarch64 elf format")
+	}
+	testExtDis(t, "gnu", arch, objdump, generate, allowedMismatchObjdump)
+	testExtDis(t, "plan9", arch, objdump, generate, allowedMismatchObjdump)
+}
+
+func objdumpinfo() bool {
+	var i = []byte("aarch64")
+	out, err := exec.Command(objdumpPath, "-i").Output()
+	if err != nil {
+		log.Fatal(err)
+	}
+	if bytes.Contains(out, i) {
+		return true
+	}
+	return false
+}
+
+func objdump(ext *ExtDis) error {
+	// File already written with instructions; add ELF header.
+	if ext.Arch == ModeARM64 {
+		if err := writeELF64(ext.File, ext.Size); err != nil {
+			return err
+		}
+	} else {
+		panic("unknown arch")
+	}
+
+	b, err := ext.Run(objdumpPath, "-d", "-z", ext.File.Name())
+	if err != nil {
+		return err
+	}
+
+	var (
+		nmatch  int
+		reading bool
+		next    uint64 = start
+		addr    uint64
+		encbuf  [4]byte
+		enc     []byte
+		text    string
+	)
+	flush := func() {
+		if addr == next {
+			// PC-relative addresses are translated to absolute addresses based on PC by GNU objdump
+			// Following logical rewrites the absolute addresses back to PC-relative ones for comparing
+			// with our disassembler output which are PC-relative
+
+			if m := pcrelprfmim.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr)))
+			}
+			if m := pcrelprfm.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr)))
+			}
+			if m := pcrelim.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr)))
+			}
+			if m := pcrelimzr.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr)))
+			}
+			if m := pcrelr.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				if strings.Contains(m[1], "adrp") {
+					text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr&0xfffff000)))
+				} else {
+					text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr)))
+				}
+			}
+			if m := pcrelrzr.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				if strings.Contains(m[1], "adrp") {
+					text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr&0xfffff000)))
+				} else {
+					text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr)))
+				}
+			}
+			if m := pcrel.FindStringSubmatch(text); m != nil {
+				targ, _ := strconv.ParseUint(m[2], 16, 64)
+				text = fmt.Sprintf("%s .%+#x", m[1], uint64(targ-uint64(addr)))
+			}
+			if strings.HasPrefix(text, "mov") && strings.Contains(text, "//") {
+				s := strings.Split(text, " //")
+				text = s[0]
+			}
+			text = strings.Replace(text, "#0.0", "#0", -1)
+			if text == "undefined" && len(enc) == 4 {
+				text = "error: unknown instruction"
+				enc = nil
+			}
+			if len(enc) == 4 {
+				// prints as word but we want to record bytes
+				enc[0], enc[3] = enc[3], enc[0]
+				enc[1], enc[2] = enc[2], enc[1]
+			}
+			ext.Dec <- ExtInst{addr, encbuf, len(enc), text}
+			encbuf = [4]byte{}
+			enc = nil
+			next += 4
+		}
+	}
+	var textangle = []byte("<.text>:")
+	for {
+		line, err := b.ReadSlice('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return fmt.Errorf("reading objdump output: %v", err)
+		}
+		if bytes.Contains(line, textangle) {
+			reading = true
+			continue
+		}
+		if !reading {
+			continue
+		}
+		if debug {
+			os.Stdout.Write(line)
+		}
+		if enc1 := parseContinuation(line, encbuf[:len(enc)]); enc1 != nil {
+			enc = enc1
+			continue
+		}
+		flush()
+		nmatch++
+		addr, enc, text = parseLine(line, encbuf[:0])
+		if addr > next {
+			return fmt.Errorf("address out of sync expected <= %#x at %q in:\n%s", next, line, line)
+		}
+	}
+	flush()
+	if next != start+uint64(ext.Size) {
+		return fmt.Errorf("not enough results found [%d %d]", next, start+ext.Size)
+	}
+	if err := ext.Wait(); err != nil {
+		return fmt.Errorf("exec: %v", err)
+	}
+
+	return nil
+}
+
+var (
+	undefined     = []byte("undefined")
+	unpredictable = []byte("unpredictable")
+)
+
+func parseLine(line []byte, encstart []byte) (addr uint64, enc []byte, text string) {
+	ok := false
+	oline := line
+	i := index(line, ":\t")
+	if i < 0 {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	x, err := strconv.ParseUint(string(bytes.TrimSpace(line[:i])), 16, 32)
+	if err != nil {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	addr = uint64(x)
+	line = line[i+2:]
+	i = bytes.IndexByte(line, '\t')
+	if i < 0 {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	enc, ok = parseHex(line[:i], encstart)
+	if !ok {
+		log.Fatalf("cannot parse disassembly: %q", oline)
+	}
+	line = bytes.TrimSpace(line[i:])
+	if bytes.Contains(line, undefined) {
+		text = "undefined"
+		return
+	}
+	if false && bytes.Contains(line, unpredictable) {
+		text = "unpredictable"
+		return
+	}
+	if i := bytes.IndexByte(line, ';'); i >= 0 {
+		line = bytes.TrimSpace(line[:i])
+	}
+	text = string(fixSpace(line))
+	return
+}
+
+func parseContinuation(line []byte, enc []byte) []byte {
+	i := index(line, ":\t")
+	if i < 0 {
+		return nil
+	}
+	line = line[i+1:]
+	enc, _ = parseHex(line, enc)
+	return enc
+}
+
+// writeELF64 writes an ELF64 header to the file, describing a text
+// segment that starts at start (0x8000) and extends for size bytes.
+func writeELF64(f *os.File, size int) error {
+	f.Seek(0, 0)
+	var hdr elf.Header64
+	var prog elf.Prog64
+	var sect elf.Section64
+	var buf bytes.Buffer
+	binary.Write(&buf, binary.LittleEndian, &hdr)
+	off1 := buf.Len()
+	binary.Write(&buf, binary.LittleEndian, &prog)
+	off2 := buf.Len()
+	binary.Write(&buf, binary.LittleEndian, &sect)
+	off3 := buf.Len()
+	buf.Reset()
+	data := byte(elf.ELFDATA2LSB)
+	hdr = elf.Header64{
+		Ident:     [16]byte{0x7F, 'E', 'L', 'F', 2, data, 1},
+		Type:      2,
+		Machine:   uint16(elf.EM_AARCH64),
+		Version:   1,
+		Entry:     start,
+		Phoff:     uint64(off1),
+		Shoff:     uint64(off2),
+		Flags:     0x05000002,
+		Ehsize:    uint16(off1),
+		Phentsize: uint16(off2 - off1),
+		Phnum:     1,
+		Shentsize: uint16(off3 - off2),
+		Shnum:     3,
+		Shstrndx:  2,
+	}
+	binary.Write(&buf, binary.LittleEndian, &hdr)
+	prog = elf.Prog64{
+		Type:   1,
+		Off:    start,
+		Vaddr:  start,
+		Paddr:  start,
+		Filesz: uint64(size),
+		Memsz:  uint64(size),
+		Flags:  5,
+		Align:  start,
+	}
+	binary.Write(&buf, binary.LittleEndian, &prog)
+	binary.Write(&buf, binary.LittleEndian, &sect) // NULL section
+	sect = elf.Section64{
+		Name:      1,
+		Type:      uint32(elf.SHT_PROGBITS),
+		Addr:      start,
+		Off:       start,
+		Size:      uint64(size),
+		Flags:     uint64(elf.SHF_ALLOC | elf.SHF_EXECINSTR),
+		Addralign: 4,
+	}
+	binary.Write(&buf, binary.LittleEndian, &sect) // .text
+	sect = elf.Section64{
+		Name:      uint32(len("\x00.text\x00")),
+		Type:      uint32(elf.SHT_STRTAB),
+		Addr:      0,
+		Off:       uint64(off2 + (off3-off2)*3),
+		Size:      uint64(len("\x00.text\x00.shstrtab\x00")),
+		Addralign: 1,
+	}
+	binary.Write(&buf, binary.LittleEndian, &sect)
+	buf.WriteString("\x00.text\x00.shstrtab\x00")
+	f.Write(buf.Bytes())
+	return nil
+}

src/cmd/vendor/golang.org/x/arch/arm64/arm64asm/testdata/Makefile

+go test command:
+	cd ..; go test -run 'ObjdumpARM64Cond' -v -timeout 10h -long 2>&1 | tee log
+	cd ..; go test -run 'ObjdumpARM64Testdata' -v -timeout 10h -long 2>&1 | tee -a log
+	cd ..; go test -run 'ObjdumpARM64' -v -timeout 10h -long 2>&1 | tee -a log
+	cd ..; go test -run 'ObjdumpARM64Manual' -v -timeout 10h -long 2>&1 | tee -a log
+	cd ..; go test -run 'TestDecode'
+	cd ..; go test -run '.*'