summaryrefslogtreecommitdiff
path: root/vendor/github.com/chenzhuoyu/iasm/x86_64/operands.go
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/chenzhuoyu/iasm/x86_64/operands.go')
-rw-r--r--vendor/github.com/chenzhuoyu/iasm/x86_64/operands.go733
1 files changed, 436 insertions, 297 deletions
diff --git a/vendor/github.com/chenzhuoyu/iasm/x86_64/operands.go b/vendor/github.com/chenzhuoyu/iasm/x86_64/operands.go
index 966090225..8c4bc9f65 100644
--- a/vendor/github.com/chenzhuoyu/iasm/x86_64/operands.go
+++ b/vendor/github.com/chenzhuoyu/iasm/x86_64/operands.go
@@ -1,13 +1,13 @@
package x86_64
import (
- `errors`
- `fmt`
- `math`
- `reflect`
- `strconv`
- `strings`
- `sync/atomic`
+ "errors"
+ "fmt"
+ "math"
+ "reflect"
+ "strconv"
+ "strings"
+ "sync/atomic"
)
// RelativeOffset represents an RIP-relative offset.
@@ -15,496 +15,635 @@ type RelativeOffset int32
// String implements the fmt.Stringer interface.
func (self RelativeOffset) String() string {
- if self == 0 {
- return "(%rip)"
- } else {
- return fmt.Sprintf("%d(%%rip)", self)
- }
+ if self == 0 {
+ return "(%rip)"
+ } else {
+ return fmt.Sprintf("%d(%%rip)", self)
+ }
}
// RoundingControl represents a floating-point rounding option.
type RoundingControl uint8
const (
- // RN_SAE represents "Round Nearest", which is the default rounding option.
- RN_SAE RoundingControl = iota
+ // RN_SAE represents "Round Nearest", which is the default rounding option.
+ RN_SAE RoundingControl = iota
- // RD_SAE represents "Round Down".
- RD_SAE
+ // RD_SAE represents "Round Down".
+ RD_SAE
- // RU_SAE represents "Round Up".
- RU_SAE
+ // RU_SAE represents "Round Up".
+ RU_SAE
- // RZ_SAE represents "Round towards Zero".
- RZ_SAE
+ // RZ_SAE represents "Round towards Zero".
+ RZ_SAE
)
-var _RC_NAMES = map[RoundingControl]string {
- RN_SAE: "rn-sae",
- RD_SAE: "rd-sae",
- RU_SAE: "ru-sae",
- RZ_SAE: "rz-sae",
+var _RC_NAMES = map[RoundingControl]string{
+ RN_SAE: "rn-sae",
+ RD_SAE: "rd-sae",
+ RU_SAE: "ru-sae",
+ RZ_SAE: "rz-sae",
}
func (self RoundingControl) String() string {
- if v, ok := _RC_NAMES[self]; ok {
- return v
- } else {
- panic("invalid RoundingControl value")
- }
+ if v, ok := _RC_NAMES[self]; ok {
+ return v
+ } else {
+ panic("invalid RoundingControl value")
+ }
}
// ExceptionControl represents the "Suppress All Exceptions" flag.
type ExceptionControl uint8
const (
- // SAE represents the flag "Suppress All Exceptions" for floating point operations.
- SAE ExceptionControl = iota
+ // SAE represents the flag "Suppress All Exceptions" for floating point operations.
+ SAE ExceptionControl = iota
)
func (ExceptionControl) String() string {
- return "sae"
+ return "sae"
}
// AddressType indicates which kind of value that an Addressable object contains.
type AddressType uint
const (
- // None indicates the Addressable does not contain any addressable value.
- None AddressType = iota
+ // None indicates the Addressable does not contain any addressable value.
+ None AddressType = iota
- // Memory indicates the Addressable contains a memory address.
- Memory
+ // Memory indicates the Addressable contains a memory address.
+ Memory
- // Offset indicates the Addressable contains an RIP-relative offset.
- Offset
+ // Offset indicates the Addressable contains an RIP-relative offset.
+ Offset
- // Reference indicates the Addressable contains a label reference.
- Reference
+ // Reference indicates the Addressable contains a label reference.
+ Reference
)
// Disposable is a type of object that can be Free'd manually.
type Disposable interface {
- Free()
+ Free()
}
// Label represents a location within the program.
type Label struct {
- refs int64
- Name string
- Dest *Instruction
+ refs int64
+ Name string
+ Dest *Instruction
}
func (self *Label) offset(p uintptr, n int) RelativeOffset {
- if self.Dest == nil {
- panic("unresolved label: " + self.Name)
- } else {
- return RelativeOffset(self.Dest.pc - p - uintptr(n))
- }
+ if self.Dest == nil {
+ panic("unresolved label: " + self.Name)
+ } else {
+ return RelativeOffset(self.Dest.pc - p - uintptr(n))
+ }
}
// Free decreases the reference count of a Label, if the
// refcount drops to 0, the Label will be recycled.
func (self *Label) Free() {
- if atomic.AddInt64(&self.refs, -1) == 0 {
- freeLabel(self)
- }
+ if atomic.AddInt64(&self.refs, -1) == 0 {
+ //freeLabel(self)
+ }
}
// String implements the fmt.Stringer interface.
func (self *Label) String() string {
- if self.Dest == nil {
- return fmt.Sprintf("%s(%%rip)", self.Name)
- } else {
- return fmt.Sprintf("%s(%%rip)@%#x", self.Name, self.Dest.pc)
- }
+ if self.Dest == nil {
+ return fmt.Sprintf("%s(%%rip)", self.Name)
+ } else {
+ return fmt.Sprintf("%s(%%rip)@%#x", self.Name, self.Dest.pc)
+ }
}
// Retain increases the reference count of a Label.
func (self *Label) Retain() *Label {
- atomic.AddInt64(&self.refs, 1)
- return self
+ atomic.AddInt64(&self.refs, 1)
+ return self
}
// Evaluate implements the interface expr.Term.
func (self *Label) Evaluate() (int64, error) {
- if self.Dest != nil {
- return int64(self.Dest.pc), nil
- } else {
- return 0, errors.New("unresolved label: " + self.Name)
- }
+ if self.Dest != nil {
+ return int64(self.Dest.pc), nil
+ } else {
+ return 0, errors.New("unresolved label: " + self.Name)
+ }
}
// Addressable is a union to represent an addressable operand.
type Addressable struct {
- Type AddressType
- Memory MemoryAddress
- Offset RelativeOffset
- Reference *Label
+ Type AddressType
+ Memory MemoryAddress
+ Offset RelativeOffset
+ Reference *Label
}
// String implements the fmt.Stringer interface.
func (self *Addressable) String() string {
- switch self.Type {
- case None : return "(not addressable)"
- case Memory : return self.Memory.String()
- case Offset : return self.Offset.String()
- case Reference : return self.Reference.String()
- default : return "(invalid addressable)"
- }
+ switch self.Type {
+ case None:
+ return "(not addressable)"
+ case Memory:
+ return self.Memory.String()
+ case Offset:
+ return self.Offset.String()
+ case Reference:
+ return self.Reference.String()
+ default:
+ return "(invalid addressable)"
+ }
}
// MemoryOperand represents a memory operand for an instruction.
type MemoryOperand struct {
- refs int64
- Size int
- Addr Addressable
- Mask RegisterMask
- Masked bool
- Broadcast uint8
+ refs int64
+ Size int
+ Addr Addressable
+ Mask RegisterMask
+ Masked bool
+ Broadcast uint8
}
const (
- _Sizes = 0b10000000100010111 // bit-mask for valid sizes (0, 1, 2, 4, 8, 16)
+ _Sizes = 0b10000000100010111 // bit-mask for valid sizes (0, 1, 2, 4, 8, 16)
)
func (self *MemoryOperand) isVMX(evex bool) bool {
- return self.Addr.Type == Memory && self.Addr.Memory.isVMX(evex)
+ return self.Addr.Type == Memory && self.Addr.Memory.isVMX(evex)
}
func (self *MemoryOperand) isVMY(evex bool) bool {
- return self.Addr.Type == Memory && self.Addr.Memory.isVMY(evex)
+ return self.Addr.Type == Memory && self.Addr.Memory.isVMY(evex)
}
func (self *MemoryOperand) isVMZ() bool {
- return self.Addr.Type == Memory && self.Addr.Memory.isVMZ()
+ return self.Addr.Type == Memory && self.Addr.Memory.isVMZ()
}
func (self *MemoryOperand) isMem() bool {
- if (_Sizes & (1 << self.Broadcast)) == 0 {
- return false
- } else if self.Addr.Type == Memory {
- return self.Addr.Memory.isMem()
- } else if self.Addr.Type == Offset {
- return true
- } else if self.Addr.Type == Reference {
- return true
- } else {
- return false
- }
+ if (_Sizes & (1 << self.Broadcast)) == 0 {
+ return false
+ } else if self.Addr.Type == Memory {
+ return self.Addr.Memory.isMem()
+ } else if self.Addr.Type == Offset {
+ return true
+ } else if self.Addr.Type == Reference {
+ return true
+ } else {
+ return false
+ }
}
func (self *MemoryOperand) isSize(n int) bool {
- return self.Size == 0 || self.Size == n
+ return self.Size == 0 || self.Size == n
}
func (self *MemoryOperand) isBroadcast(n int, b uint8) bool {
- return self.Size == n && self.Broadcast == b
+ return self.Size == n && self.Broadcast == b
}
func (self *MemoryOperand) formatMask() string {
- if !self.Masked {
- return ""
- } else {
- return self.Mask.String()
- }
+ if !self.Masked {
+ return ""
+ } else {
+ return self.Mask.String()
+ }
}
func (self *MemoryOperand) formatBroadcast() string {
- if self.Broadcast == 0 {
- return ""
- } else {
- return fmt.Sprintf("{1to%d}", self.Broadcast)
- }
+ if self.Broadcast == 0 {
+ return ""
+ } else {
+ return fmt.Sprintf("{1to%d}", self.Broadcast)
+ }
}
func (self *MemoryOperand) ensureAddrValid() {
- switch self.Addr.Type {
- case None : break
- case Memory : self.Addr.Memory.EnsureValid()
- case Offset : break
- case Reference : break
- default : panic("invalid address type")
- }
+ switch self.Addr.Type {
+ case None:
+ break
+ case Memory:
+ self.Addr.Memory.EnsureValid()
+ case Offset:
+ break
+ case Reference:
+ break
+ default:
+ panic("invalid address type")
+ }
}
func (self *MemoryOperand) ensureSizeValid() {
- if (_Sizes & (1 << self.Size)) == 0 {
- panic("invalid memory operand size")
- }
+ if (_Sizes & (1 << self.Size)) == 0 {
+ panic("invalid memory operand size")
+ }
}
func (self *MemoryOperand) ensureBroadcastValid() {
- if (_Sizes & (1 << self.Broadcast)) == 0 {
- panic("invalid memory operand broadcast")
- }
+ if (_Sizes & (1 << self.Broadcast)) == 0 {
+ panic("invalid memory operand broadcast")
+ }
}
// Free decreases the reference count of a MemoryOperand, if the
// refcount drops to 0, the Label will be recycled.
func (self *MemoryOperand) Free() {
- if atomic.AddInt64(&self.refs, -1) == 0 {
- freeMemoryOperand(self)
- }
+ if atomic.AddInt64(&self.refs, -1) == 0 {
+ //freeMemoryOperand(self)
+ }
}
// String implements the fmt.Stringer interface.
func (self *MemoryOperand) String() string {
- return self.Addr.String() + self.formatMask() + self.formatBroadcast()
+ return self.Addr.String() + self.formatMask() + self.formatBroadcast()
}
// Retain increases the reference count of a MemoryOperand.
func (self *MemoryOperand) Retain() *MemoryOperand {
- atomic.AddInt64(&self.refs, 1)
- return self
+ atomic.AddInt64(&self.refs, 1)
+ return self
}
// EnsureValid checks if the memory operand is valid, if not, it panics.
func (self *MemoryOperand) EnsureValid() {
- self.ensureAddrValid()
- self.ensureSizeValid()
- self.ensureBroadcastValid()
+ self.ensureAddrValid()
+ self.ensureSizeValid()
+ self.ensureBroadcastValid()
}
// MemoryAddress represents a memory address.
type MemoryAddress struct {
- Base Register
- Index Register
- Scale uint8
- Displacement int32
+ Base Register
+ Index Register
+ Scale uint8
+ Displacement int32
}
const (
- _Scales = 0b100010111 // bit-mask for valid scales (0, 1, 2, 4, 8)
+ _Scales = 0b100010111 // bit-mask for valid scales (0, 1, 2, 4, 8)
)
func (self *MemoryAddress) isVMX(evex bool) bool {
- return self.isMemBase() && (self.Index == nil || isXMM(self.Index) || (evex && isEVEXXMM(self.Index)))
+ return self.isMemBase() && (self.Index == nil || isXMM(self.Index) || (evex && isEVEXXMM(self.Index)))
}
func (self *MemoryAddress) isVMY(evex bool) bool {
- return self.isMemBase() && (self.Index == nil || isYMM(self.Index) || (evex && isEVEXYMM(self.Index)))
+ return self.isMemBase() && (self.Index == nil || isYMM(self.Index) || (evex && isEVEXYMM(self.Index)))
}
func (self *MemoryAddress) isVMZ() bool {
- return self.isMemBase() && (self.Index == nil || isZMM(self.Index))
+ return self.isMemBase() && (self.Index == nil || isZMM(self.Index))
}
func (self *MemoryAddress) isMem() bool {
- return self.isMemBase() && (self.Index == nil || isReg64(self.Index))
+ return self.isMemBase() && (self.Index == nil || isReg64(self.Index))
}
func (self *MemoryAddress) isMemBase() bool {
- return (self.Base == nil || isReg64(self.Base)) && // `Base` must be 64-bit if present
- (self.Scale == 0) == (self.Index == nil) && // `Scale` and `Index` depends on each other
- (_Scales & (1 << self.Scale)) != 0 // `Scale` can only be 0, 1, 2, 4 or 8
+ return (self.Base == nil || isReg64(self.Base)) && // `Base` must be 64-bit if present
+ (self.Scale == 0) == (self.Index == nil) && // `Scale` and `Index` depends on each other
+ (_Scales&(1<<self.Scale)) != 0 // `Scale` can only be 0, 1, 2, 4 or 8
}
// String implements the fmt.Stringer interface.
func (self *MemoryAddress) String() string {
- var dp int
- var sb strings.Builder
+ var dp int
+ var sb strings.Builder
- /* the displacement part */
- if dp = int(self.Displacement); dp != 0 {
- sb.WriteString(strconv.Itoa(dp))
- }
+ /* the displacement part */
+ if dp = int(self.Displacement); dp != 0 {
+ sb.WriteString(strconv.Itoa(dp))
+ }
- /* the base register */
- if sb.WriteByte('('); self.Base != nil {
- sb.WriteByte('%')
- sb.WriteString(self.Base.String())
- }
+ /* the base register */
+ if sb.WriteByte('('); self.Base != nil {
+ sb.WriteByte('%')
+ sb.WriteString(self.Base.String())
+ }
- /* index is optional */
- if self.Index != nil {
- sb.WriteString(",%")
- sb.WriteString(self.Index.String())
+ /* index is optional */
+ if self.Index != nil {
+ sb.WriteString(",%")
+ sb.WriteString(self.Index.String())
- /* scale is also optional */
- if self.Scale >= 2 {
- sb.WriteByte(',')
- sb.WriteString(strconv.Itoa(int(self.Scale)))
- }
- }
+ /* scale is also optional */
+ if self.Scale >= 2 {
+ sb.WriteByte(',')
+ sb.WriteString(strconv.Itoa(int(self.Scale)))
+ }
+ }
- /* close the bracket */
- sb.WriteByte(')')
- return sb.String()
+ /* close the bracket */
+ sb.WriteByte(')')
+ return sb.String()
}
// EnsureValid checks if the memory address is valid, if not, it panics.
func (self *MemoryAddress) EnsureValid() {
- if !self.isMemBase() || (self.Index != nil && !isIndexable(self.Index)) {
- panic("not a valid memory address")
- }
+ if !self.isMemBase() || (self.Index != nil && !isIndexable(self.Index)) {
+ panic("not a valid memory address")
+ }
}
// Ref constructs a memory reference to a label.
func Ref(ref *Label) (v *MemoryOperand) {
- v = CreateMemoryOperand()
- v.Addr.Type = Reference
- v.Addr.Reference = ref
- return
+ v = CreateMemoryOperand()
+ v.Addr.Type = Reference
+ v.Addr.Reference = ref
+ return
}
// Abs construct a simple memory address that represents absolute addressing.
func Abs(disp int32) *MemoryOperand {
- return Sib(nil, nil, 0, disp)
+ return Sib(nil, nil, 0, disp)
}
// Ptr constructs a simple memory operand with base and displacement.
func Ptr(base Register, disp int32) *MemoryOperand {
- return Sib(base, nil, 0, disp)
+ return Sib(base, nil, 0, disp)
}
// Sib constructs a simple memory operand that represents a complete memory address.
func Sib(base Register, index Register, scale uint8, disp int32) (v *MemoryOperand) {
- v = CreateMemoryOperand()
- v.Addr.Type = Memory
- v.Addr.Memory.Base = base
- v.Addr.Memory.Index = index
- v.Addr.Memory.Scale = scale
- v.Addr.Memory.Displacement = disp
- v.EnsureValid()
- return
+ v = CreateMemoryOperand()
+ v.Addr.Type = Memory
+ v.Addr.Memory.Base = base
+ v.Addr.Memory.Index = index
+ v.Addr.Memory.Scale = scale
+ v.Addr.Memory.Displacement = disp
+ v.EnsureValid()
+ return
}
/** Operand Matching Helpers **/
-const _IntMask =
- (1 << reflect.Int ) |
- (1 << reflect.Int8 ) |
- (1 << reflect.Int16 ) |
- (1 << reflect.Int32 ) |
- (1 << reflect.Int64 ) |
- (1 << reflect.Uint ) |
- (1 << reflect.Uint8 ) |
- (1 << reflect.Uint16 ) |
- (1 << reflect.Uint32 ) |
- (1 << reflect.Uint64 ) |
- (1 << reflect.Uintptr)
+const _IntMask = (1 << reflect.Int) |
+ (1 << reflect.Int8) |
+ (1 << reflect.Int16) |
+ (1 << reflect.Int32) |
+ (1 << reflect.Int64) |
+ (1 << reflect.Uint) |
+ (1 << reflect.Uint8) |
+ (1 << reflect.Uint16) |
+ (1 << reflect.Uint32) |
+ (1 << reflect.Uint64) |
+ (1 << reflect.Uintptr)
func isInt(k reflect.Kind) bool {
- return (_IntMask & (1 << k)) != 0
+ return (_IntMask & (1 << k)) != 0
}
func asInt64(v interface{}) (int64, bool) {
- if isSpecial(v) {
- return 0, false
- } else if x := efaceOf(v); isInt(x.kind()) {
- return x.toInt64(), true
- } else {
- return 0, false
- }
+ if isSpecial(v) {
+ return 0, false
+ } else if x := efaceOf(v); isInt(x.kind()) {
+ return x.toInt64(), true
+ } else {
+ return 0, false
+ }
}
func inRange(v interface{}, low int64, high int64) bool {
- x, ok := asInt64(v)
- return ok && x >= low && x <= high
+ x, ok := asInt64(v)
+ return ok && x >= low && x <= high
}
func isSpecial(v interface{}) bool {
- switch v.(type) {
- case Register8 : return true
- case Register16 : return true
- case Register32 : return true
- case Register64 : return true
- case KRegister : return true
- case MMRegister : return true
- case XMMRegister : return true
- case YMMRegister : return true
- case ZMMRegister : return true
- case RelativeOffset : return true
- case RoundingControl : return true
- case ExceptionControl : return true
- default : return false
- }
+ switch v.(type) {
+ case Register8:
+ return true
+ case Register16:
+ return true
+ case Register32:
+ return true
+ case Register64:
+ return true
+ case KRegister:
+ return true
+ case MMRegister:
+ return true
+ case XMMRegister:
+ return true
+ case YMMRegister:
+ return true
+ case ZMMRegister:
+ return true
+ case RelativeOffset:
+ return true
+ case RoundingControl:
+ return true
+ case ExceptionControl:
+ return true
+ default:
+ return false
+ }
}
func isIndexable(v interface{}) bool {
- return isZMM(v) || isReg64(v) || isEVEXXMM(v) || isEVEXYMM(v)
-}
-
-func isImm4 (v interface{}) bool { return inRange(v, 0, 15) }
-func isImm8 (v interface{}) bool { return inRange(v, math.MinInt8, math.MaxUint8) }
-func isImm16 (v interface{}) bool { return inRange(v, math.MinInt16, math.MaxUint16) }
-func isImm32 (v interface{}) bool { return inRange(v, math.MinInt32, math.MaxUint32) }
-func isImm64 (v interface{}) bool { _, r := asInt64(v) ; return r }
-func isConst1 (v interface{}) bool { x, r := asInt64(v) ; return r && x == 1 }
-func isConst3 (v interface{}) bool { x, r := asInt64(v) ; return r && x == 3 }
-func isRel8 (v interface{}) bool { x, r := v.(RelativeOffset) ; return r && x >= math.MinInt8 && x <= math.MaxInt8 }
-func isRel32 (v interface{}) bool { _, r := v.(RelativeOffset) ; return r }
-func isLabel (v interface{}) bool { _, r := v.(*Label) ; return r }
-func isReg8 (v interface{}) bool { _, r := v.(Register8) ; return r }
-func isReg8REX (v interface{}) bool { x, r := v.(Register8) ; return r && (x & 0x80) == 0 && x >= SPL }
-func isReg16 (v interface{}) bool { _, r := v.(Register16) ; return r }
-func isReg32 (v interface{}) bool { _, r := v.(Register32) ; return r }
-func isReg64 (v interface{}) bool { _, r := v.(Register64) ; return r }
-func isMM (v interface{}) bool { _, r := v.(MMRegister) ; return r }
-func isXMM (v interface{}) bool { x, r := v.(XMMRegister) ; return r && x <= XMM15 }
-func isEVEXXMM (v interface{}) bool { _, r := v.(XMMRegister) ; return r }
-func isXMMk (v interface{}) bool { x, r := v.(MaskedRegister) ; return isXMM(v) || (r && isXMM(x.Reg) && !x.Mask.Z) }
-func isXMMkz (v interface{}) bool { x, r := v.(MaskedRegister) ; return isXMM(v) || (r && isXMM(x.Reg)) }
-func isYMM (v interface{}) bool { x, r := v.(YMMRegister) ; return r && x <= YMM15 }
-func isEVEXYMM (v interface{}) bool { _, r := v.(YMMRegister) ; return r }
-func isYMMk (v interface{}) bool { x, r := v.(MaskedRegister) ; return isYMM(v) || (r && isYMM(x.Reg) && !x.Mask.Z) }
-func isYMMkz (v interface{}) bool { x, r := v.(MaskedRegister) ; return isYMM(v) || (r && isYMM(x.Reg)) }
-func isZMM (v interface{}) bool { _, r := v.(ZMMRegister) ; return r }
-func isZMMk (v interface{}) bool { x, r := v.(MaskedRegister) ; return isZMM(v) || (r && isZMM(x.Reg) && !x.Mask.Z) }
-func isZMMkz (v interface{}) bool { x, r := v.(MaskedRegister) ; return isZMM(v) || (r && isZMM(x.Reg)) }
-func isK (v interface{}) bool { _, r := v.(KRegister) ; return r }
-func isKk (v interface{}) bool { x, r := v.(MaskedRegister) ; return isK(v) || (r && isK(x.Reg) && !x.Mask.Z) }
-func isM (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isMem() && x.Broadcast == 0 && !x.Masked }
-func isMk (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isMem() && x.Broadcast == 0 && !(x.Masked && x.Mask.Z) }
-func isMkz (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isMem() && x.Broadcast == 0 }
-func isM8 (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isM(v) && x.isSize(1) }
-func isM16 (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isM(v) && x.isSize(2) }
-func isM16kz (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMkz(v) && x.isSize(2) }
-func isM32 (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isM(v) && x.isSize(4) }
-func isM32k (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMk(v) && x.isSize(4) }
-func isM32kz (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMkz(v) && x.isSize(4) }
-func isM64 (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isM(v) && x.isSize(8) }
-func isM64k (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMk(v) && x.isSize(8) }
-func isM64kz (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMkz(v) && x.isSize(8) }
-func isM128 (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isM(v) && x.isSize(16) }
-func isM128kz (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMkz(v) && x.isSize(16) }
-func isM256 (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isM(v) && x.isSize(32) }
-func isM256kz (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMkz(v) && x.isSize(32) }
-func isM512 (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isM(v) && x.isSize(64) }
-func isM512kz (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && isMkz(v) && x.isSize(64) }
-func isM64M32bcst (v interface{}) bool { x, r := v.(*MemoryOperand) ; return isM64(v) || (r && x.isBroadcast(4, 2)) }
-func isM128M32bcst (v interface{}) bool { x, r := v.(*MemoryOperand) ; return isM128(v) || (r && x.isBroadcast(4, 4)) }
-func isM256M32bcst (v interface{}) bool { x, r := v.(*MemoryOperand) ; return isM256(v) || (r && x.isBroadcast(4, 8)) }
-func isM512M32bcst (v interface{}) bool { x, r := v.(*MemoryOperand) ; return isM512(v) || (r && x.isBroadcast(4, 16)) }
-func isM128M64bcst (v interface{}) bool { x, r := v.(*MemoryOperand) ; return isM128(v) || (r && x.isBroadcast(8, 2)) }
-func isM256M64bcst (v interface{}) bool { x, r := v.(*MemoryOperand) ; return isM256(v) || (r && x.isBroadcast(8, 4)) }
-func isM512M64bcst (v interface{}) bool { x, r := v.(*MemoryOperand) ; return isM512(v) || (r && x.isBroadcast(8, 8)) }
-func isVMX (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMX(false) && !x.Masked }
-func isEVEXVMX (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMX(true) && !x.Masked }
-func isVMXk (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMX(true) }
-func isVMY (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMY(false) && !x.Masked }
-func isEVEXVMY (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMY(true) && !x.Masked }
-func isVMYk (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMY(true) }
-func isVMZ (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMZ() && !x.Masked }
-func isVMZk (v interface{}) bool { x, r := v.(*MemoryOperand) ; return r && x.isVMZ() }
-func isSAE (v interface{}) bool { _, r := v.(ExceptionControl) ; return r }
-func isER (v interface{}) bool { _, r := v.(RoundingControl) ; return r }
+ return isZMM(v) || isReg64(v) || isEVEXXMM(v) || isEVEXYMM(v)
+}
+
+func isImm4(v interface{}) bool { return inRange(v, 0, 15) }
+func isImm8(v interface{}) bool { return inRange(v, math.MinInt8, math.MaxUint8) }
+func isImm16(v interface{}) bool { return inRange(v, math.MinInt16, math.MaxUint16) }
+func isImm32(v interface{}) bool { return inRange(v, math.MinInt32, math.MaxUint32) }
+func isImm64(v interface{}) bool { _, r := asInt64(v); return r }
+func isConst1(v interface{}) bool { x, r := asInt64(v); return r && x == 1 }
+func isConst3(v interface{}) bool { x, r := asInt64(v); return r && x == 3 }
+func isRel8(v interface{}) bool {
+ x, r := v.(RelativeOffset)
+ return r && x >= math.MinInt8 && x <= math.MaxInt8
+}
+func isRel32(v interface{}) bool { _, r := v.(RelativeOffset); return r }
+func isLabel(v interface{}) bool { _, r := v.(*Label); return r }
+func isReg8(v interface{}) bool { _, r := v.(Register8); return r }
+func isReg8REX(v interface{}) bool {
+ x, r := v.(Register8)
+ return r && (x&0x80) == 0 && x >= SPL
+}
+func isReg16(v interface{}) bool { _, r := v.(Register16); return r }
+func isReg32(v interface{}) bool { _, r := v.(Register32); return r }
+func isReg64(v interface{}) bool { _, r := v.(Register64); return r }
+func isMM(v interface{}) bool { _, r := v.(MMRegister); return r }
+func isXMM(v interface{}) bool { x, r := v.(XMMRegister); return r && x <= XMM15 }
+func isEVEXXMM(v interface{}) bool { _, r := v.(XMMRegister); return r }
+func isXMMk(v interface{}) bool {
+ x, r := v.(MaskedRegister)
+ return isXMM(v) || (r && isXMM(x.Reg) && !x.Mask.Z)
+}
+func isXMMkz(v interface{}) bool {
+ x, r := v.(MaskedRegister)
+ return isXMM(v) || (r && isXMM(x.Reg))
+}
+func isYMM(v interface{}) bool { x, r := v.(YMMRegister); return r && x <= YMM15 }
+func isEVEXYMM(v interface{}) bool { _, r := v.(YMMRegister); return r }
+func isYMMk(v interface{}) bool {
+ x, r := v.(MaskedRegister)
+ return isYMM(v) || (r && isYMM(x.Reg) && !x.Mask.Z)
+}
+func isYMMkz(v interface{}) bool {
+ x, r := v.(MaskedRegister)
+ return isYMM(v) || (r && isYMM(x.Reg))
+}
+func isZMM(v interface{}) bool { _, r := v.(ZMMRegister); return r }
+func isZMMk(v interface{}) bool {
+ x, r := v.(MaskedRegister)
+ return isZMM(v) || (r && isZMM(x.Reg) && !x.Mask.Z)
+}
+func isZMMkz(v interface{}) bool {
+ x, r := v.(MaskedRegister)
+ return isZMM(v) || (r && isZMM(x.Reg))
+}
+func isK(v interface{}) bool { _, r := v.(KRegister); return r }
+func isKk(v interface{}) bool {
+ x, r := v.(MaskedRegister)
+ return isK(v) || (r && isK(x.Reg) && !x.Mask.Z)
+}
+func isM(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isMem() && x.Broadcast == 0 && !x.Masked
+}
+func isMk(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isMem() && x.Broadcast == 0 && !(x.Masked && x.Mask.Z)
+}
+func isMkz(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isMem() && x.Broadcast == 0
+}
+func isM8(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isM(v) && x.isSize(1)
+}
+func isM16(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isM(v) && x.isSize(2)
+}
+func isM16kz(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMkz(v) && x.isSize(2)
+}
+func isM32(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isM(v) && x.isSize(4)
+}
+func isM32k(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMk(v) && x.isSize(4)
+}
+func isM32kz(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMkz(v) && x.isSize(4)
+}
+func isM64(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isM(v) && x.isSize(8)
+}
+func isM64k(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMk(v) && x.isSize(8)
+}
+func isM64kz(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMkz(v) && x.isSize(8)
+}
+func isM128(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isM(v) && x.isSize(16)
+}
+func isM128kz(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMkz(v) && x.isSize(16)
+}
+func isM256(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isM(v) && x.isSize(32)
+}
+func isM256kz(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMkz(v) && x.isSize(32)
+}
+func isM512(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isM(v) && x.isSize(64)
+}
+func isM512kz(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && isMkz(v) && x.isSize(64)
+}
+func isM64M32bcst(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return isM64(v) || (r && x.isBroadcast(4, 2))
+}
+func isM128M32bcst(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return isM128(v) || (r && x.isBroadcast(4, 4))
+}
+func isM256M32bcst(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return isM256(v) || (r && x.isBroadcast(4, 8))
+}
+func isM512M32bcst(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return isM512(v) || (r && x.isBroadcast(4, 16))
+}
+func isM128M64bcst(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return isM128(v) || (r && x.isBroadcast(8, 2))
+}
+func isM256M64bcst(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return isM256(v) || (r && x.isBroadcast(8, 4))
+}
+func isM512M64bcst(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return isM512(v) || (r && x.isBroadcast(8, 8))
+}
+func isVMX(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isVMX(false) && !x.Masked
+}
+func isEVEXVMX(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isVMX(true) && !x.Masked
+}
+func isVMXk(v interface{}) bool { x, r := v.(*MemoryOperand); return r && x.isVMX(true) }
+func isVMY(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isVMY(false) && !x.Masked
+}
+func isEVEXVMY(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isVMY(true) && !x.Masked
+}
+func isVMYk(v interface{}) bool { x, r := v.(*MemoryOperand); return r && x.isVMY(true) }
+func isVMZ(v interface{}) bool {
+ x, r := v.(*MemoryOperand)
+ return r && x.isVMZ() && !x.Masked
+}
+func isVMZk(v interface{}) bool { x, r := v.(*MemoryOperand); return r && x.isVMZ() }
+func isSAE(v interface{}) bool { _, r := v.(ExceptionControl); return r }
+func isER(v interface{}) bool { _, r := v.(RoundingControl); return r }
func isImmExt(v interface{}, ext int, min int64, max int64) bool {
- if x, ok := asInt64(v); !ok {
- return false
- } else if m := int64(1) << (8 * ext); x < m && x >= m + min {
- return true
- } else {
- return x <= max && x >= min
- }
+ if x, ok := asInt64(v); !ok {
+ return false
+ } else if m := int64(1) << (8 * ext); x < m && x >= m+min {
+ return true
+ } else {
+ return x <= max && x >= min
+ }
}
func isImm8Ext(v interface{}, ext int) bool {
- return isImmExt(v, ext, math.MinInt8, math.MaxInt8)
+ return isImmExt(v, ext, math.MinInt8, math.MaxInt8)
}
func isImm32Ext(v interface{}, ext int) bool {
- return isImmExt(v, ext, math.MinInt32, math.MaxInt32)
+ return isImmExt(v, ext, math.MinInt32, math.MaxInt32)
}
generated by cgit v1.2.3 (git 2.46.0) at 2025-08-04 16:09:04 +0000