X = ""
			if arg.Sign < 0 {
				X = "-"
			}
			X += gnuArg(inst, -1, arg.Index)
			if arg.Shift == ShiftLeft && arg.Count == 0 {
				// nothing
			} else if arg.Shift == RotateRightExt {
				X += ", rrx"
			} else {
				X += fmt.Sprintf(", %s #%d", strings.ToLower(arg.Shift.String()), arg.Count)
			}
		} else {
			X = fmt.Sprintf("#%d", arg.Offset)
		}

		switch arg.Mode {
		case AddrOffset:

	RRX:               "RRX",
	RRX_ZZ:            "RRX.ZZ",
	RRX_S_EQ:          "RRX.S.EQ",
	RRX_S_NE:          "RRX.S.NE",
	RRX_S_CS:          "RRX.S.CS",
	RRX_S_CC:          "RRX.S.CC",
	RRX_S_MI:          "RRX.S.MI",
	RRX_S_PL:          "RRX.S.PL",
	RRX_S_VS:          "RRX.S.VS",
	RRX_S_VC:          "RRX.S.VC",
	RRX_S_HI:          "RRX.S.HI",
	RRX_S_LS:          "RRX.S.LS",

	RotateRight      Shift = 3 // right rotate
	RotateRightExt   Shift = 4 // right rotate through carry (Count will always be 1)
)

var shiftName = [...]string{
	"LSL", "LSR", "ASR", "ROR", "RRX",
}

func (s Shift) String() string {
	if s < 5 {
		return shiftName[s]
	}
	return fmt.Sprintf("Shift(%d)", int(s))
}

// A RegShift is a register shifted by a constant.
type RegShift struct {

		}
		return Mem{Base: Reg((x >> 16) & (1<<4 - 1)), Mode: mode}

	case arg_R_rotate:
		Rm := Reg(x & (1<<4 - 1))
		typ, count := decodeShift(x)
		// ROR #0 here means ROR #0, but decodeShift rewrites to RRX #1.
		if typ == RotateRightExt {
			return Rm
		}
		return RegShift{Rm, typ, count}

	case arg_R_shift_R:
		Rm := Reg(x & (1<<4 - 1))
		Rs := Reg((x >> 8) & (1<<4 - 1))