diff --git a/core/rexcode/isa/x86/encoder.odin b/core/rexcode/isa/x86/encoder.odin index c269dad27..1230401b5 100644 --- a/core/rexcode/isa/x86/encoder.odin +++ b/core/rexcode/isa/x86/encoder.odin @@ -192,13 +192,23 @@ encode :: proc( mr_slot: int = -1 reg_slot: int = -1 opr_slot: int = -1 + imm_slot: int = -1 + has_gpr16 := false // any GPR16 operand -> 66h operand-size prefix + has_spl := false // any SPL/BPL/SIL/DIL (GPR8 hw 4-7) -> forces a REX { user_idx := 0 for op, i in enc.ops { if op == .NONE { break } if !is_implicit_op_inline(op) { if user_idx < int(inst.operand_count) { - user_ops[i] = &inst.ops[user_idx] + uop := &inst.ops[user_idx] + user_ops[i] = uop + if uop.kind == .REGISTER { + cls := reg_class(uop.reg) + hw := reg_hw(uop.reg) + has_gpr16 ||= cls == REG_GPR16 + has_spl ||= cls == REG_GPR8 && hw >= 4 && hw <= 7 + } } user_idx += 1 } @@ -207,6 +217,7 @@ encode :: proc( case .MR: mr_slot = i case .REG: reg_slot = i case .OP_R: opr_slot = i + case .IB, .IW, .ID, .IQ: imm_slot = i } } } @@ -214,34 +225,36 @@ encode :: proc( // --- Legacy Prefixes --- // - // Kept as predicted branches: in real instruction streams a legacy - // prefix is almost always absent, so these are ~100% predicted-not-taken - // (free), and the branchless speculative-write form only added four - // unconditional stores per instruction for no win. See git history. + // The vast majority of instructions carry no legacy prefix, so gate the + // whole block on a single flags-is-zero test instead of four separate + // predicted-not-taken branches per instruction. Inside, the branches are + // kept (a present prefix is rare enough that the branching form beats the + // branchless speculative-write one -- see git history). + if transmute(u8)inst.flags != 0 { + // Lock prefix (F0) + if inst.flags.lock && enc.flags.lock_ok { + out[pos] = 0xF0 + pos += 1 + } - // Lock prefix (F0) - if inst.flags.lock && enc.flags.lock_ok { - out[pos] = 0xF0 - pos += 1 - } + // Rep/Repne prefix + #partial switch inst.flags.rep { + case .REP: out[pos] = 0xF3; pos += 1 + case .REPNE: out[pos] = 0xF2; pos += 1 + } - // Rep/Repne prefix - #partial switch inst.flags.rep { - case .REP: out[pos] = 0xF3; pos += 1 - case .REPNE: out[pos] = 0xF2; pos += 1 - } + // Segment override + if inst.flags.segment != 0 { + seg_prefix := [8]u8{0, 0x26, 0x2E, 0x36, 0x3E, 0x64, 0x65, 0} + out[pos] = seg_prefix[inst.flags.segment] + pos += 1 + } - // Segment override - if inst.flags.segment != 0 { - seg_prefix := [8]u8{0, 0x26, 0x2E, 0x36, 0x3E, 0x64, 0x65, 0} - out[pos] = seg_prefix[inst.flags.segment] - pos += 1 - } - - // Address size override (67h) - if inst.flags.addr32 { - out[pos] = 0x67 - pos += 1 + // Address size override (67h) + if inst.flags.addr32 { + out[pos] = 0x67 + pos += 1 + } } // --- VEX/EVEX or Legacy Encoding --- @@ -374,14 +387,8 @@ encode :: proc( pos += 4 case: // Legacy encoding - // Operand size override (66h) - needs_66 := false - for i in 0.. REX.B - rex |= bmask(base_ext) & 0x41 - rex |= bmask(index_ext) & 0x42 - case .OP_R: - rex |= bmask(reg_ext) & 0x41 + if reg_slot >= 0 { + op := user_ops[reg_slot] + if op != nil { + rex |= bmask(op.kind == .REGISTER && reg_needs_rex(op.reg)) & 0x44 + } + } + if mr_slot >= 0 { + op := user_ops[mr_slot] + if op != nil { + is_reg := op.kind == .REGISTER + is_mem := op.kind == .MEMORY + m := op.mem // union bytes; only used when is_mem + rex |= bmask(is_reg && reg_needs_rex(op.reg)) & 0x41 + rex |= bmask(is_mem && mem_has_base(m) && m.base_ext) & 0x41 + rex |= bmask(is_mem && mem_has_index(m) && m.index_ext) & 0x42 + } + } + if opr_slot >= 0 { + op := user_ops[opr_slot] + if op != nil { + rex |= bmask(op.kind == .REGISTER && reg_needs_rex(op.reg)) & 0x41 } } - // SPL/BPL/SIL/DIL (GPR8 hw 4-7) require an empty REX (long mode only). - if mode == ._64 { - spl_seen := false - for i in 0..= 4 && hw <= 7 - } - rex |= bmask(rex == 0 && spl_seen) & 0x40 - } + // SPL/BPL/SIL/DIL (has_spl, computed in the resolve pass) force an + // empty REX in long mode when no other REX bit is set. + rex |= bmask(mode == ._64 && rex == 0 && has_spl) & 0x40 // 32-bit mode forbids the REX prefix entirely. If any operand // demanded REX bits (R8-R15, SPL/BPL/SIL/DIL, force_rex_w), @@ -611,55 +610,44 @@ encode :: proc( pos += 1 } - // --- Immediates --- - for enc_type, i in enc.enc { - #partial switch enc_type { + // --- Immediate (single precomputed slot, no scan over enc.enc) --- + if imm_slot >= 0 && user_ops[imm_slot] != nil { + user_op := user_ops[imm_slot] + #partial switch enc.enc[imm_slot] { case .IB: - user_op := user_ops[i] - if user_op != nil { - #partial switch user_op.kind { - case .IMMEDIATE: - out[pos] = u8(user_op.immediate) - pos += 1 - case .RELATIVE: - // Relative reference - record relocation - label_id := u32(user_op.relative) - append(&pending_relocations, Relocation{byte_count + pos, label_id, 0, .REL8, 1, u16(instruction_index)}) - out[pos] = 0 - pos += 1 - } + #partial switch user_op.kind { + case .IMMEDIATE: + out[pos] = u8(user_op.immediate) + pos += 1 + case .RELATIVE: + label_id := u32(user_op.relative) + append(&pending_relocations, Relocation{byte_count + pos, label_id, 0, .REL8, 1, u16(instruction_index)}) + out[pos] = 0 + pos += 1 } - case .IW: - user_op := user_ops[i] - if user_op != nil && user_op.kind == .IMMEDIATE { - immediate_val := u16(user_op.immediate) - out[pos] = u8(immediate_val); out[pos+1] = u8(immediate_val >> 8) + if user_op.kind == .IMMEDIATE { + v := u16(user_op.immediate) + out[pos] = u8(v); out[pos+1] = u8(v >> 8) pos += 2 } - case .ID: - user_op := user_ops[i] - if user_op != nil { - #partial switch user_op.kind { - case .IMMEDIATE: - immediate_val := u32(user_op.immediate) - out[pos] = u8(immediate_val); out[pos+1] = u8(immediate_val >> 8) - out[pos+2] = u8(immediate_val >> 16); out[pos+3] = u8(immediate_val >> 24) - pos += 4 - case .RELATIVE: - label_id := u32(user_op.relative) - append(&pending_relocations, Relocation{byte_count + pos, label_id, 0, .REL32, 4, u16(instruction_index)}) - out[pos] = 0; out[pos+1] = 0; out[pos+2] = 0; out[pos+3] = 0 - pos += 4 - } + #partial switch user_op.kind { + case .IMMEDIATE: + v := u32(user_op.immediate) + out[pos] = u8(v); out[pos+1] = u8(v >> 8); out[pos+2] = u8(v >> 16); out[pos+3] = u8(v >> 24) + pos += 4 + case .RELATIVE: + label_id := u32(user_op.relative) + append(&pending_relocations, Relocation{byte_count + pos, label_id, 0, .REL32, 4, u16(instruction_index)}) + out[pos] = 0; out[pos+1] = 0; out[pos+2] = 0; out[pos+3] = 0 + pos += 4 } - case .IQ: - user_op := user_ops[i] - if user_op != nil && user_op.kind == .IMMEDIATE { - immediate_val := u64(user_op.immediate) - for j in u32(0)..<8 { out[pos + j] = u8(immediate_val >> (j * 8)) } + if user_op.kind == .IMMEDIATE { + v := u64(user_op.immediate) + out[pos] = u8(v); out[pos+1] = u8(v >> 8); out[pos+2] = u8(v >> 16); out[pos+3] = u8(v >> 24) + out[pos+4] = u8(v >> 32); out[pos+5] = u8(v >> 40); out[pos+6] = u8(v >> 48); out[pos+7] = u8(v >> 56) pos += 8 } } diff --git a/core/rexcode/isa/x86/mnemonic_builders.odin b/core/rexcode/isa/x86/mnemonic_builders.odin index c6b6ec9f8..c7b518e03 100644 --- a/core/rexcode/isa/x86/mnemonic_builders.odin +++ b/core/rexcode/isa/x86/mnemonic_builders.odin @@ -83,15 +83,15 @@ inst_mov_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_mov_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 6) } inst_mov_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 7) } inst_mov_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 8) } -inst_mov_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_mov_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_mov_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_mov_r64_imm64 :: #force_inline proc "contextless" (dst: GPR64, imm: i64) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_imm64(imm), {}, {}} } } -inst_mov_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_mov_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_mov_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_mov_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_mov_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_mov_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 9) } +inst_mov_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 10) } +inst_mov_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 11) } +inst_mov_r64_imm64 :: #force_inline proc "contextless" (dst: GPR64, imm: i64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_imm64(imm), {}, {}} }, 12) } +inst_mov_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 13) } +inst_mov_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 14) } +inst_mov_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 15) } +inst_mov_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 16) } +inst_mov_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 16) } inst_mov_r16_sreg :: #force_inline proc "contextless" (dst: GPR16, src: SREG) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr16(dst), op_sreg(src), {}, {}} }, 25) } inst_mov_m16_sreg :: #force_inline proc "contextless" (dst: Mem16, src: SREG) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_mem(dst.mem, 2), op_sreg(src), {}, {}} }, 25) } inst_mov_r64_sreg :: #force_inline proc "contextless" (dst: GPR64, src: SREG) -> Instruction { return with_hint(Instruction{ mnemonic = .MOV, operand_count = 2, ops = {op_gpr64(dst), op_sreg(src), {}, {}} }, 26) } @@ -137,7 +137,7 @@ emit_mov_r64_cr :: #force_inline proc(instructions: ^[dynami emit_mov_cr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: CREG, src: GPR64) { append(instructions, inst_mov_cr_r64(dst, src)) } emit_mov_r64_dr :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: DREG) { append(instructions, inst_mov_r64_dr(dst, src)) } emit_mov_dr_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: DREG, src: GPR64) { append(instructions, inst_mov_dr_r64(dst, src)) } -inst_movabs_r64_imm64 :: #force_inline proc "contextless" (dst: GPR64, imm: i64) -> Instruction { return Instruction{ mnemonic = .MOVABS, operand_count = 2, ops = {op_gpr64(dst), op_imm64(imm), {}, {}} } } +inst_movabs_r64_imm64 :: #force_inline proc "contextless" (dst: GPR64, imm: i64) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVABS, operand_count = 2, ops = {op_gpr64(dst), op_imm64(imm), {}, {}} }, 33) } emit_movabs_r64_imm64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i64) { append(instructions, inst_movabs_r64_imm64(dst, imm)) } inst_movzx_r16_r8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr16(dst), op_gpr8(src), {}, {}} }, 42) } inst_movzx_r16_m8 :: #force_inline proc "contextless" (dst: GPR16, src: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .MOVZX, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 1), {}, {}} }, 42) } @@ -209,8 +209,8 @@ inst_push_r16 :: #force_inline proc "contextless" (dst: GP inst_push_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 61) } inst_push_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 62) } inst_push_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 63) } -inst_push_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_push_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } +inst_push_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 65) } +inst_push_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 66) } inst_push_sreg :: #force_inline proc "contextless" (dst: SREG) -> Instruction { return with_hint(Instruction{ mnemonic = .PUSH, operand_count = 1, ops = {op_sreg(dst), {}, {}, {}} }, 67) } emit_push_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_push_r16(dst)) } emit_push_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64) { append(instructions, inst_push_r64(dst)) } @@ -247,17 +247,17 @@ inst_add_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_add_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 83) } inst_add_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 84) } inst_add_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 85) } -inst_add_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_add_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_add_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_add_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_add_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_add_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_add_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_add_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_add_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_add_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_add_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_add_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 86) } +inst_add_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 87) } +inst_add_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 88) } +inst_add_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 90) } +inst_add_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 90) } +inst_add_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 91) } +inst_add_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 91) } +inst_add_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 92) } +inst_add_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 92) } +inst_add_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 93) } +inst_add_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADD, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 93) } emit_add_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_add_r8_r8(dst, src)) } emit_add_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_add_m8_r8(dst, src)) } emit_add_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_add_r16_r16(dst, src)) } @@ -293,17 +293,17 @@ inst_adc_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_adc_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 102) } inst_adc_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 103) } inst_adc_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 104) } -inst_adc_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_adc_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_adc_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_adc_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_adc_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_adc_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_adc_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_adc_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_adc_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_adc_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_adc_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_adc_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 105) } +inst_adc_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 106) } +inst_adc_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 107) } +inst_adc_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 109) } +inst_adc_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 109) } +inst_adc_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 110) } +inst_adc_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 110) } +inst_adc_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 111) } +inst_adc_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 111) } +inst_adc_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 112) } +inst_adc_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .ADC, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 112) } emit_adc_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_adc_r8_r8(dst, src)) } emit_adc_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_adc_m8_r8(dst, src)) } emit_adc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_adc_r16_r16(dst, src)) } @@ -339,17 +339,17 @@ inst_sub_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_sub_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 121) } inst_sub_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 122) } inst_sub_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 123) } -inst_sub_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_sub_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_sub_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_sub_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_sub_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_sub_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_sub_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_sub_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_sub_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_sub_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_sub_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_sub_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 124) } +inst_sub_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 125) } +inst_sub_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 126) } +inst_sub_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 128) } +inst_sub_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 128) } +inst_sub_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 129) } +inst_sub_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 129) } +inst_sub_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 130) } +inst_sub_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 130) } +inst_sub_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 131) } +inst_sub_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SUB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 131) } emit_sub_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_sub_r8_r8(dst, src)) } emit_sub_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_sub_m8_r8(dst, src)) } emit_sub_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_sub_r16_r16(dst, src)) } @@ -385,17 +385,17 @@ inst_sbb_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_sbb_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 140) } inst_sbb_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 141) } inst_sbb_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 142) } -inst_sbb_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_sbb_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_sbb_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_sbb_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_sbb_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_sbb_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_sbb_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_sbb_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_sbb_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_sbb_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_sbb_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_sbb_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 143) } +inst_sbb_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 144) } +inst_sbb_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 145) } +inst_sbb_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 147) } +inst_sbb_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 147) } +inst_sbb_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 148) } +inst_sbb_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 148) } +inst_sbb_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 149) } +inst_sbb_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 149) } +inst_sbb_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 150) } +inst_sbb_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .SBB, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 150) } emit_sbb_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_sbb_r8_r8(dst, src)) } emit_sbb_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_sbb_m8_r8(dst, src)) } emit_sbb_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_sbb_r16_r16(dst, src)) } @@ -449,12 +449,12 @@ inst_imul_r32_r32 :: #force_inline proc "contextless" (dst: GP inst_imul_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 163) } inst_imul_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 164) } inst_imul_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 164) } -inst_imul_r16_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr16(dst), op_gpr16(src), op_imm16(imm), {}} } } -inst_imul_r16_m16_imm16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr16(dst), op_mem(src.mem, 2), op_imm16(imm), {}} } } -inst_imul_r32_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm32(imm), {}} } } -inst_imul_r32_m32_imm32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_imm32(imm), {}} } } -inst_imul_r64_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm32(imm), {}} } } -inst_imul_r64_m64_imm32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_imm32(imm), {}} } } +inst_imul_r16_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr16(dst), op_gpr16(src), op_imm16(imm), {}} }, 168) } +inst_imul_r16_m16_imm16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr16(dst), op_mem(src.mem, 2), op_imm16(imm), {}} }, 168) } +inst_imul_r32_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm32(imm), {}} }, 169) } +inst_imul_r32_m32_imm32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_imm32(imm), {}} }, 169) } +inst_imul_r64_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm32(imm), {}} }, 170) } +inst_imul_r64_m64_imm32 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .IMUL, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_imm32(imm), {}} }, 170) } emit_imul_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_imul_r8(dst)) } emit_imul_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_imul_m8(dst)) } emit_imul_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16) { append(instructions, inst_imul_r16(dst)) } @@ -567,17 +567,17 @@ inst_cmp_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_cmp_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 200) } inst_cmp_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 201) } inst_cmp_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 202) } -inst_cmp_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_cmp_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_cmp_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_cmp_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_cmp_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_cmp_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_cmp_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_cmp_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_cmp_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_cmp_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_cmp_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_cmp_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 203) } +inst_cmp_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 204) } +inst_cmp_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 205) } +inst_cmp_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 207) } +inst_cmp_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 207) } +inst_cmp_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 208) } +inst_cmp_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 208) } +inst_cmp_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 209) } +inst_cmp_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 209) } +inst_cmp_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 210) } +inst_cmp_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .CMP, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 210) } emit_cmp_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_cmp_r8_r8(dst, src)) } emit_cmp_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_cmp_m8_r8(dst, src)) } emit_cmp_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_cmp_r16_r16(dst, src)) } @@ -613,17 +613,17 @@ inst_and_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_and_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 219) } inst_and_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 220) } inst_and_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 221) } -inst_and_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_and_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_and_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_and_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_and_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_and_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_and_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_and_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_and_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_and_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_and_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_and_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 222) } +inst_and_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 223) } +inst_and_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 224) } +inst_and_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 226) } +inst_and_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 226) } +inst_and_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 227) } +inst_and_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 227) } +inst_and_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 228) } +inst_and_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 228) } +inst_and_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 229) } +inst_and_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .AND, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 229) } emit_and_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_and_r8_r8(dst, src)) } emit_and_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_and_m8_r8(dst, src)) } emit_and_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_and_r16_r16(dst, src)) } @@ -659,17 +659,17 @@ inst_or_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_or_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 238) } inst_or_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 239) } inst_or_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 240) } -inst_or_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_or_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_or_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_or_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_or_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_or_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_or_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_or_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_or_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_or_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_or_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_or_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 241) } +inst_or_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 242) } +inst_or_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 243) } +inst_or_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 245) } +inst_or_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 245) } +inst_or_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 246) } +inst_or_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 246) } +inst_or_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 247) } +inst_or_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 247) } +inst_or_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 248) } +inst_or_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .OR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 248) } emit_or_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_or_r8_r8(dst, src)) } emit_or_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_or_m8_r8(dst, src)) } emit_or_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_or_r16_r16(dst, src)) } @@ -705,17 +705,17 @@ inst_xor_r8_m8 :: #force_inline proc "contextless" (dst: GP inst_xor_r16_m16 :: #force_inline proc "contextless" (dst: GPR16, src: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr16(dst), op_mem(src.mem, 2), {}, {}} }, 257) } inst_xor_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 258) } inst_xor_r64_m64 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr64(dst), op_mem(src.mem, 8), {}, {}} }, 259) } -inst_xor_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_xor_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_xor_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_xor_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_xor_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_xor_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_xor_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_xor_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_xor_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_xor_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_xor_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_xor_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 260) } +inst_xor_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 261) } +inst_xor_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 262) } +inst_xor_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 264) } +inst_xor_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 264) } +inst_xor_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 265) } +inst_xor_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 265) } +inst_xor_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 266) } +inst_xor_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 266) } +inst_xor_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 267) } +inst_xor_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .XOR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 267) } emit_xor_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_xor_r8_r8(dst, src)) } emit_xor_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_xor_m8_r8(dst, src)) } emit_xor_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_xor_r16_r16(dst, src)) } @@ -763,17 +763,17 @@ inst_test_r32_r32 :: #force_inline proc "contextless" (dst: GP inst_test_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 277) } inst_test_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 278) } inst_test_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 278) } -inst_test_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } -inst_test_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } -inst_test_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} } } -inst_test_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_test_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } -inst_test_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} } } -inst_test_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} } } -inst_test_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} } } -inst_test_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} } } -inst_test_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} } } -inst_test_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} } } +inst_test_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 279) } +inst_test_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 280) } +inst_test_imm32 :: #force_inline proc "contextless" (imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 1, ops = {op_imm32(imm), {}, {}, {}} }, 281) } +inst_test_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 283) } +inst_test_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 283) } +inst_test_r16_imm16 :: #force_inline proc "contextless" (dst: GPR16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr16(dst), op_imm16(imm), {}, {}} }, 284) } +inst_test_m16_imm16 :: #force_inline proc "contextless" (dst: Mem16, imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm16(imm), {}, {}} }, 284) } +inst_test_r32_imm32 :: #force_inline proc "contextless" (dst: GPR32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr32(dst), op_imm32(imm), {}, {}} }, 285) } +inst_test_m32_imm32 :: #force_inline proc "contextless" (dst: Mem32, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm32(imm), {}, {}} }, 285) } +inst_test_r64_imm32 :: #force_inline proc "contextless" (dst: GPR64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_gpr64(dst), op_imm32(imm), {}, {}} }, 286) } +inst_test_m64_imm32 :: #force_inline proc "contextless" (dst: Mem64, imm: i32) -> Instruction { return with_hint(Instruction{ mnemonic = .TEST, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm32(imm), {}, {}} }, 286) } emit_test_r8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: GPR8) { append(instructions, inst_test_r8_r8(dst, src)) } emit_test_m8_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: GPR8) { append(instructions, inst_test_m8_r8(dst, src)) } emit_test_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_test_r16_r16(dst, src)) } @@ -795,20 +795,20 @@ emit_test_r64_imm32 :: #force_inline proc(instructions: ^[dynami emit_test_m64_imm32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i32) { append(instructions, inst_test_m64_imm32(dst, imm)) } inst_shl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 287) } inst_shl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 287) } -inst_shl_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_shl_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } +inst_shl_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 289) } +inst_shl_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 289) } inst_shl_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 290) } inst_shl_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 290) } -inst_shl_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_shl_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } +inst_shl_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 292) } +inst_shl_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 292) } inst_shl_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 293) } inst_shl_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 293) } -inst_shl_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_shl_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } +inst_shl_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 295) } +inst_shl_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 295) } inst_shl_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 296) } inst_shl_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 296) } -inst_shl_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_shl_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_shl_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 298) } +inst_shl_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHL, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 298) } emit_shl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_shl_r8(dst)) } emit_shl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_shl_m8(dst)) } emit_shl_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_shl_r8_imm8(dst, imm)) } @@ -827,20 +827,20 @@ emit_shl_r64_imm8 :: #force_inline proc(instructions: ^[dynami emit_shl_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_shl_m64_imm8(dst, imm)) } inst_shr_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 299) } inst_shr_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 299) } -inst_shr_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_shr_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } +inst_shr_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 301) } +inst_shr_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 301) } inst_shr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 302) } inst_shr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 302) } -inst_shr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_shr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } +inst_shr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 304) } +inst_shr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 304) } inst_shr_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 305) } inst_shr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 305) } -inst_shr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_shr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } +inst_shr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 307) } +inst_shr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 307) } inst_shr_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 308) } inst_shr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 308) } -inst_shr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_shr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_shr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 310) } +inst_shr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 310) } emit_shr_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_shr_r8(dst)) } emit_shr_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_shr_m8(dst)) } emit_shr_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_shr_r8_imm8(dst, imm)) } @@ -859,20 +859,20 @@ emit_shr_r64_imm8 :: #force_inline proc(instructions: ^[dynami emit_shr_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_shr_m64_imm8(dst, imm)) } inst_sar_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 311) } inst_sar_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 311) } -inst_sar_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_sar_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } +inst_sar_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 313) } +inst_sar_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 313) } inst_sar_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 314) } inst_sar_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 314) } -inst_sar_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_sar_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } +inst_sar_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 316) } +inst_sar_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 316) } inst_sar_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 317) } inst_sar_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 317) } -inst_sar_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_sar_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } +inst_sar_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 319) } +inst_sar_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 319) } inst_sar_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 320) } inst_sar_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 320) } -inst_sar_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_sar_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_sar_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 322) } +inst_sar_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SAR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 322) } emit_sar_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_sar_r8(dst)) } emit_sar_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_sar_m8(dst)) } emit_sar_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_sar_r8_imm8(dst, imm)) } @@ -891,20 +891,20 @@ emit_sar_r64_imm8 :: #force_inline proc(instructions: ^[dynami emit_sar_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_sar_m64_imm8(dst, imm)) } inst_rol_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 323) } inst_rol_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 323) } -inst_rol_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_rol_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } +inst_rol_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 325) } +inst_rol_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 325) } inst_rol_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 326) } inst_rol_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 326) } -inst_rol_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_rol_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } +inst_rol_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 328) } +inst_rol_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 328) } inst_rol_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 329) } inst_rol_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 329) } -inst_rol_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_rol_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } +inst_rol_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 331) } +inst_rol_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 331) } inst_rol_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 332) } inst_rol_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 332) } -inst_rol_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_rol_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_rol_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 334) } +inst_rol_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROL, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 334) } emit_rol_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_rol_r8(dst)) } emit_rol_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_rol_m8(dst)) } emit_rol_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_rol_r8_imm8(dst, imm)) } @@ -923,20 +923,20 @@ emit_rol_r64_imm8 :: #force_inline proc(instructions: ^[dynami emit_rol_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_rol_m64_imm8(dst, imm)) } inst_ror_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 335) } inst_ror_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 335) } -inst_ror_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_ror_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } +inst_ror_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 337) } +inst_ror_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 337) } inst_ror_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 338) } inst_ror_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 338) } -inst_ror_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_ror_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } +inst_ror_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 340) } +inst_ror_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 340) } inst_ror_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 341) } inst_ror_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 341) } -inst_ror_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_ror_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } +inst_ror_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 343) } +inst_ror_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 343) } inst_ror_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 344) } inst_ror_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 344) } -inst_ror_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_ror_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_ror_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 346) } +inst_ror_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 346) } emit_ror_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_ror_r8(dst)) } emit_ror_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_ror_m8(dst)) } emit_ror_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_ror_r8_imm8(dst, imm)) } @@ -955,20 +955,20 @@ emit_ror_r64_imm8 :: #force_inline proc(instructions: ^[dynami emit_ror_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_ror_m64_imm8(dst, imm)) } inst_rcl_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 347) } inst_rcl_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 347) } -inst_rcl_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_rcl_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } +inst_rcl_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 349) } +inst_rcl_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 349) } inst_rcl_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 350) } inst_rcl_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 350) } -inst_rcl_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_rcl_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } +inst_rcl_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 352) } +inst_rcl_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 352) } inst_rcl_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 353) } inst_rcl_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 353) } -inst_rcl_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_rcl_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } +inst_rcl_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 355) } +inst_rcl_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 355) } inst_rcl_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 356) } inst_rcl_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 356) } -inst_rcl_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_rcl_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_rcl_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 358) } +inst_rcl_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCL, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 358) } emit_rcl_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_rcl_r8(dst)) } emit_rcl_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_rcl_m8(dst)) } emit_rcl_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_rcl_r8_imm8(dst, imm)) } @@ -987,20 +987,20 @@ emit_rcl_r64_imm8 :: #force_inline proc(instructions: ^[dynami emit_rcl_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_rcl_m64_imm8(dst, imm)) } inst_rcr_r8 :: #force_inline proc "contextless" (dst: GPR8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_gpr8(dst), {}, {}, {}} }, 359) } inst_rcr_m8 :: #force_inline proc "contextless" (dst: Mem8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_mem(dst.mem, 1), {}, {}, {}} }, 359) } -inst_rcr_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} } } -inst_rcr_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} } } +inst_rcr_r8_imm8 :: #force_inline proc "contextless" (dst: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr8(dst), op_imm8(imm), {}, {}} }, 361) } +inst_rcr_m8_imm8 :: #force_inline proc "contextless" (dst: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 1), op_imm8(imm), {}, {}} }, 361) } inst_rcr_r16 :: #force_inline proc "contextless" (dst: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_gpr16(dst), {}, {}, {}} }, 362) } inst_rcr_m16 :: #force_inline proc "contextless" (dst: Mem16) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_mem(dst.mem, 2), {}, {}, {}} }, 362) } -inst_rcr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_rcr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } +inst_rcr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 364) } +inst_rcr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 364) } inst_rcr_r32 :: #force_inline proc "contextless" (dst: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_gpr32(dst), {}, {}, {}} }, 365) } inst_rcr_m32 :: #force_inline proc "contextless" (dst: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_mem(dst.mem, 4), {}, {}, {}} }, 365) } -inst_rcr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_rcr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } +inst_rcr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 367) } +inst_rcr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 367) } inst_rcr_r64 :: #force_inline proc "contextless" (dst: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_gpr64(dst), {}, {}, {}} }, 368) } inst_rcr_m64 :: #force_inline proc "contextless" (dst: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 1, ops = {op_mem(dst.mem, 8), {}, {}, {}} }, 368) } -inst_rcr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_rcr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_rcr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 370) } +inst_rcr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RCR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 370) } emit_rcr_r8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8) { append(instructions, inst_rcr_r8(dst)) } emit_rcr_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8) { append(instructions, inst_rcr_m8(dst)) } emit_rcr_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, imm: i8) { append(instructions, inst_rcr_r8_imm8(dst, imm)) } @@ -1017,12 +1017,12 @@ emit_rcr_r64 :: #force_inline proc(instructions: ^[dynami emit_rcr_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_rcr_m64(dst)) } emit_rcr_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, imm: i8) { append(instructions, inst_rcr_r64_imm8(dst, imm)) } emit_rcr_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, imm: i8) { append(instructions, inst_rcr_m64_imm8(dst, imm)) } -inst_shld_r16_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_gpr16(dst), op_gpr16(src), op_imm8(imm), {}} } } -inst_shld_m16_r16_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_mem(dst.mem, 2), op_gpr16(src), op_imm8(imm), {}} } } -inst_shld_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm8(imm), {}} } } -inst_shld_m32_r32_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_gpr32(src), op_imm8(imm), {}} } } -inst_shld_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm8(imm), {}} } } -inst_shld_m64_r64_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_mem(dst.mem, 8), op_gpr64(src), op_imm8(imm), {}} } } +inst_shld_r16_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_gpr16(dst), op_gpr16(src), op_imm8(imm), {}} }, 371) } +inst_shld_m16_r16_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_mem(dst.mem, 2), op_gpr16(src), op_imm8(imm), {}} }, 371) } +inst_shld_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm8(imm), {}} }, 372) } +inst_shld_m32_r32_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_gpr32(src), op_imm8(imm), {}} }, 372) } +inst_shld_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm8(imm), {}} }, 373) } +inst_shld_m64_r64_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 3, ops = {op_mem(dst.mem, 8), op_gpr64(src), op_imm8(imm), {}} }, 373) } inst_shld_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 374) } inst_shld_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 374) } inst_shld_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHLD, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 375) } @@ -1041,12 +1041,12 @@ emit_shld_r32_r32 :: #force_inline proc(instructions: ^[dynami emit_shld_m32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: GPR32) { append(instructions, inst_shld_m32_r32(dst, src)) } emit_shld_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_shld_r64_r64(dst, src)) } emit_shld_m64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: GPR64) { append(instructions, inst_shld_m64_r64(dst, src)) } -inst_shrd_r16_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_gpr16(dst), op_gpr16(src), op_imm8(imm), {}} } } -inst_shrd_m16_r16_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_mem(dst.mem, 2), op_gpr16(src), op_imm8(imm), {}} } } -inst_shrd_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm8(imm), {}} } } -inst_shrd_m32_r32_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_gpr32(src), op_imm8(imm), {}} } } -inst_shrd_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm8(imm), {}} } } -inst_shrd_m64_r64_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_mem(dst.mem, 8), op_gpr64(src), op_imm8(imm), {}} } } +inst_shrd_r16_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_gpr16(dst), op_gpr16(src), op_imm8(imm), {}} }, 377) } +inst_shrd_m16_r16_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_mem(dst.mem, 2), op_gpr16(src), op_imm8(imm), {}} }, 377) } +inst_shrd_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm8(imm), {}} }, 378) } +inst_shrd_m32_r32_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_gpr32(src), op_imm8(imm), {}} }, 378) } +inst_shrd_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm8(imm), {}} }, 379) } +inst_shrd_m64_r64_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 3, ops = {op_mem(dst.mem, 8), op_gpr64(src), op_imm8(imm), {}} }, 379) } inst_shrd_r16_r16 :: #force_inline proc "contextless" (dst: GPR16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 2, ops = {op_gpr16(dst), op_gpr16(src), {}, {}} }, 380) } inst_shrd_m16_r16 :: #force_inline proc "contextless" (dst: Mem16, src: GPR16) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 2, ops = {op_mem(dst.mem, 2), op_gpr16(src), {}, {}} }, 380) } inst_shrd_r32_r32 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .SHRD, operand_count = 2, ops = {op_gpr32(dst), op_gpr32(src), {}, {}} }, 381) } @@ -1071,12 +1071,12 @@ inst_bt_r32_r32 :: #force_inline proc "contextless" (dst: GP inst_bt_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 384) } inst_bt_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 385) } inst_bt_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 385) } -inst_bt_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_bt_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } -inst_bt_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_bt_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } -inst_bt_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_bt_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_bt_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 386) } +inst_bt_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 386) } +inst_bt_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 387) } +inst_bt_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 387) } +inst_bt_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 388) } +inst_bt_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BT, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 388) } emit_bt_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_bt_r16_r16(dst, src)) } emit_bt_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_bt_m16_r16(dst, src)) } emit_bt_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_bt_r32_r32(dst, src)) } @@ -1095,12 +1095,12 @@ inst_bts_r32_r32 :: #force_inline proc "contextless" (dst: GP inst_bts_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 390) } inst_bts_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 391) } inst_bts_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 391) } -inst_bts_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_bts_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } -inst_bts_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_bts_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } -inst_bts_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_bts_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_bts_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 392) } +inst_bts_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 392) } +inst_bts_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 393) } +inst_bts_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 393) } +inst_bts_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 394) } +inst_bts_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTS, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 394) } emit_bts_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_bts_r16_r16(dst, src)) } emit_bts_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_bts_m16_r16(dst, src)) } emit_bts_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_bts_r32_r32(dst, src)) } @@ -1119,12 +1119,12 @@ inst_btr_r32_r32 :: #force_inline proc "contextless" (dst: GP inst_btr_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 396) } inst_btr_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 397) } inst_btr_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 397) } -inst_btr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_btr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } -inst_btr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_btr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } -inst_btr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_btr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_btr_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 398) } +inst_btr_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 398) } +inst_btr_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 399) } +inst_btr_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 399) } +inst_btr_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 400) } +inst_btr_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTR, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 400) } emit_btr_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_btr_r16_r16(dst, src)) } emit_btr_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_btr_m16_r16(dst, src)) } emit_btr_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_btr_r32_r32(dst, src)) } @@ -1143,12 +1143,12 @@ inst_btc_r32_r32 :: #force_inline proc "contextless" (dst: GP inst_btc_m32_r32 :: #force_inline proc "contextless" (dst: Mem32, src: GPR32) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 4), op_gpr32(src), {}, {}} }, 402) } inst_btc_r64_r64 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr64(dst), op_gpr64(src), {}, {}} }, 403) } inst_btc_m64_r64 :: #force_inline proc "contextless" (dst: Mem64, src: GPR64) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 8), op_gpr64(src), {}, {}} }, 403) } -inst_btc_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} } } -inst_btc_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} } } -inst_btc_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} } } -inst_btc_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} } } -inst_btc_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} } } -inst_btc_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} } } +inst_btc_r16_imm8 :: #force_inline proc "contextless" (dst: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr16(dst), op_imm8(imm), {}, {}} }, 404) } +inst_btc_m16_imm8 :: #force_inline proc "contextless" (dst: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 2), op_imm8(imm), {}, {}} }, 404) } +inst_btc_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr32(dst), op_imm8(imm), {}, {}} }, 405) } +inst_btc_m32_imm8 :: #force_inline proc "contextless" (dst: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 4), op_imm8(imm), {}, {}} }, 405) } +inst_btc_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_gpr64(dst), op_imm8(imm), {}, {}} }, 406) } +inst_btc_m64_imm8 :: #force_inline proc "contextless" (dst: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BTC, operand_count = 2, ops = {op_mem(dst.mem, 8), op_imm8(imm), {}, {}} }, 406) } emit_btc_r16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: GPR16) { append(instructions, inst_btc_r16_r16(dst, src)) } emit_btc_m16_r16 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: GPR16) { append(instructions, inst_btc_m16_r16(dst, src)) } emit_btc_r32_r32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32) { append(instructions, inst_btc_r32_r32(dst, src)) } @@ -1372,7 +1372,7 @@ emit_call_r64 :: #force_inline proc(instructions: ^[dynami emit_call_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64) { append(instructions, inst_call_m64(dst)) } emit_call_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Memory) { append(instructions, inst_call_m(dst)) } inst_ret_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .RET, operand_count = 0, ops = {{}, {}, {}, {}} }, 499) } -inst_ret_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return Instruction{ mnemonic = .RET, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} } } +inst_ret_imm16 :: #force_inline proc "contextless" (imm: i16) -> Instruction { return with_hint(Instruction{ mnemonic = .RET, operand_count = 1, ops = {op_imm16(imm), {}, {}, {}} }, 500) } emit_ret_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_ret_none()) } emit_ret_imm16 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16) { append(instructions, inst_ret_imm16(imm)) } inst_iret_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .IRET, operand_count = 0, ops = {{}, {}, {}, {}} }, 501) } @@ -1381,7 +1381,7 @@ inst_iretd_none :: #force_inline proc "contextless" () -> In emit_iretd_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_iretd_none()) } inst_iretq_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .IRETQ, operand_count = 0, ops = {{}, {}, {}, {}} }, 503) } emit_iretq_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_iretq_none()) } -inst_int_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return Instruction{ mnemonic = .INT, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} } } +inst_int_imm8 :: #force_inline proc "contextless" (imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .INT, operand_count = 1, ops = {op_imm8(imm), {}, {}, {}} }, 504) } emit_int_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i8) { append(instructions, inst_int_imm8(imm)) } inst_int3_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .INT3, operand_count = 0, ops = {{}, {}, {}, {}} }, 505) } emit_int3_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_int3_none()) } @@ -2073,10 +2073,10 @@ emit_pext_r32_r32_r32 :: #force_inline proc(instructions: ^[dynami emit_pext_r32_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, src2: Mem32) { append(instructions, inst_pext_r32_r32_m32(dst, src, src2)) } emit_pext_r64_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: GPR64) { append(instructions, inst_pext_r64_r64_r64(dst, src, src2)) } emit_pext_r64_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, src2: Mem64) { append(instructions, inst_pext_r64_r64_m64(dst, src, src2)) } -inst_rorx_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm8(imm), {}} } } -inst_rorx_r32_m32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_imm8(imm), {}} } } -inst_rorx_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm8(imm), {}} } } -inst_rorx_r64_m64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_imm8(imm), {}} } } +inst_rorx_r32_r32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr32(dst), op_gpr32(src), op_imm8(imm), {}} }, 709) } +inst_rorx_r32_m32_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr32(dst), op_mem(src.mem, 4), op_imm8(imm), {}} }, 709) } +inst_rorx_r64_r64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr64(dst), op_gpr64(src), op_imm8(imm), {}} }, 710) } +inst_rorx_r64_m64_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .RORX, operand_count = 3, ops = {op_gpr64(dst), op_mem(src.mem, 8), op_imm8(imm), {}} }, 710) } emit_rorx_r32_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: GPR32, imm: i8) { append(instructions, inst_rorx_r32_r32_imm8(dst, src, imm)) } emit_rorx_r32_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32, imm: i8) { append(instructions, inst_rorx_r32_m32_imm8(dst, src, imm)) } emit_rorx_r64_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64, imm: i8) { append(instructions, inst_rorx_r64_r64_imm8(dst, src, imm)) } @@ -2405,20 +2405,20 @@ inst_xorpd_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_xorpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .XORPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 806) } emit_xorpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_xorpd_xmm_xmm(dst, src)) } emit_xorpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_xorpd_xmm_m128(dst, src)) } -inst_cmpps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_cmpps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_cmpps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 807) } +inst_cmpps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 807) } emit_cmpps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_cmpps_xmm_xmm_imm8(dst, src, imm)) } emit_cmpps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_cmpps_xmm_m128_imm8(dst, src, imm)) } -inst_cmppd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_cmppd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_cmppd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 808) } +inst_cmppd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 808) } emit_cmppd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_cmppd_xmm_xmm_imm8(dst, src, imm)) } emit_cmppd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_cmppd_xmm_m128_imm8(dst, src, imm)) } -inst_cmpss_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_cmpss_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPSS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} } } +inst_cmpss_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 809) } +inst_cmpss_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} }, 809) } emit_cmpss_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_cmpss_xmm_xmm_imm8(dst, src, imm)) } emit_cmpss_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { append(instructions, inst_cmpss_xmm_m32_imm8(dst, src, imm)) } -inst_cmpsd_sse_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPSD_SSE, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_cmpsd_sse_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .CMPSD_SSE, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} } } +inst_cmpsd_sse_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSD_SSE, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 810) } +inst_cmpsd_sse_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .CMPSD_SSE, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} }, 810) } emit_cmpsd_sse_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_cmpsd_sse_xmm_xmm_imm8(dst, src, imm)) } emit_cmpsd_sse_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64, imm: i8) { append(instructions, inst_cmpsd_sse_xmm_m64_imm8(dst, src, imm)) } inst_comiss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .COMISS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 811) } @@ -2437,12 +2437,12 @@ inst_ucomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_ucomisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .UCOMISD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 814) } emit_ucomisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_ucomisd_xmm_xmm(dst, src)) } emit_ucomisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_ucomisd_xmm_m64(dst, src)) } -inst_shufps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHUFPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_shufps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHUFPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_shufps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHUFPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 815) } +inst_shufps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHUFPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 815) } emit_shufps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_shufps_xmm_xmm_imm8(dst, src, imm)) } emit_shufps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_shufps_xmm_m128_imm8(dst, src, imm)) } -inst_shufpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHUFPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_shufpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHUFPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_shufpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHUFPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 816) } +inst_shufpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHUFPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 816) } emit_shufpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_shufpd_xmm_xmm_imm8(dst, src, imm)) } emit_shufpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_shufpd_xmm_m128_imm8(dst, src, imm)) } inst_unpcklps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .UNPCKLPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 817) } @@ -2651,49 +2651,49 @@ emit_pxor_xmm_xmm :: #force_inline proc(instructions: ^[dynami emit_pxor_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pxor_xmm_m128(dst, src)) } inst_psllw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 868) } inst_psllw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 868) } -inst_psllw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSLLW, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_psllw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLW, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 869) } emit_psllw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psllw_xmm_xmm(dst, src)) } emit_psllw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psllw_xmm_m128(dst, src)) } emit_psllw_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_psllw_xmm_imm8(dst, imm)) } inst_pslld_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 870) } inst_pslld_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 870) } -inst_pslld_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSLLD, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_pslld_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLD, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 871) } emit_pslld_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pslld_xmm_xmm(dst, src)) } emit_pslld_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pslld_xmm_m128(dst, src)) } emit_pslld_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_pslld_xmm_imm8(dst, imm)) } inst_psllq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 872) } inst_psllq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 872) } -inst_psllq_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSLLQ, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_psllq_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSLLQ, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 873) } emit_psllq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psllq_xmm_xmm(dst, src)) } emit_psllq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psllq_xmm_m128(dst, src)) } emit_psllq_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_psllq_xmm_imm8(dst, imm)) } inst_psrlw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 874) } inst_psrlw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 874) } -inst_psrlw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSRLW, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_psrlw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLW, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 875) } emit_psrlw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psrlw_xmm_xmm(dst, src)) } emit_psrlw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psrlw_xmm_m128(dst, src)) } emit_psrlw_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_psrlw_xmm_imm8(dst, imm)) } inst_psrld_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 876) } inst_psrld_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 876) } -inst_psrld_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSRLD, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_psrld_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLD, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 877) } emit_psrld_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psrld_xmm_xmm(dst, src)) } emit_psrld_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psrld_xmm_m128(dst, src)) } emit_psrld_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_psrld_xmm_imm8(dst, imm)) } inst_psrlq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 878) } inst_psrlq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 878) } -inst_psrlq_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSRLQ, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_psrlq_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRLQ, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 879) } emit_psrlq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psrlq_xmm_xmm(dst, src)) } emit_psrlq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psrlq_xmm_m128(dst, src)) } emit_psrlq_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_psrlq_xmm_imm8(dst, imm)) } inst_psraw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRAW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 880) } inst_psraw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRAW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 880) } -inst_psraw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSRAW, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_psraw_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRAW, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 881) } emit_psraw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psraw_xmm_xmm(dst, src)) } emit_psraw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psraw_xmm_m128(dst, src)) } emit_psraw_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_psraw_xmm_imm8(dst, imm)) } inst_psrad_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRAD, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 882) } inst_psrad_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRAD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 882) } -inst_psrad_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSRAD, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} } } +inst_psrad_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSRAD, operand_count = 2, ops = {op_xmm(dst), op_imm8(imm), {}, {}} }, 883) } emit_psrad_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_psrad_xmm_xmm(dst, src)) } emit_psrad_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_psrad_xmm_m128(dst, src)) } emit_psrad_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, imm: i8) { append(instructions, inst_psrad_xmm_imm8(dst, imm)) } @@ -2765,28 +2765,28 @@ inst_punpckhqdq_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_punpckhqdq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PUNPCKHQDQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 900) } emit_punpckhqdq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_punpckhqdq_xmm_xmm(dst, src)) } emit_punpckhqdq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_punpckhqdq_xmm_m128(dst, src)) } -inst_pshufd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pshufd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pshufd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 901) } +inst_pshufd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 901) } emit_pshufd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pshufd_xmm_xmm_imm8(dst, src, imm)) } emit_pshufd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pshufd_xmm_m128_imm8(dst, src, imm)) } -inst_pshufhw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pshufhw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pshufhw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 902) } +inst_pshufhw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 902) } emit_pshufhw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pshufhw_xmm_xmm_imm8(dst, src, imm)) } emit_pshufhw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pshufhw_xmm_m128_imm8(dst, src, imm)) } -inst_pshuflw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pshuflw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pshuflw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 903) } +inst_pshuflw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 903) } emit_pshuflw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pshuflw_xmm_xmm_imm8(dst, src, imm)) } emit_pshuflw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pshuflw_xmm_m128_imm8(dst, src, imm)) } -inst_pshufw_mm_mm_imm8 :: #force_inline proc "contextless" (dst: MM, src: MM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFW, operand_count = 3, ops = {op_mm(dst), op_mm(src), op_imm8(imm), {}} } } -inst_pshufw_mm_m64_imm8 :: #force_inline proc "contextless" (dst: MM, src: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .PSHUFW, operand_count = 3, ops = {op_mm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} } } +inst_pshufw_mm_mm_imm8 :: #force_inline proc "contextless" (dst: MM, src: MM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFW, operand_count = 3, ops = {op_mm(dst), op_mm(src), op_imm8(imm), {}} }, 904) } +inst_pshufw_mm_m64_imm8 :: #force_inline proc "contextless" (dst: MM, src: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PSHUFW, operand_count = 3, ops = {op_mm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} }, 904) } emit_pshufw_mm_mm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: MM, imm: i8) { append(instructions, inst_pshufw_mm_mm_imm8(dst, src, imm)) } emit_pshufw_mm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: MM, src: Mem64, imm: i8) { append(instructions, inst_pshufw_mm_m64_imm8(dst, src, imm)) } -inst_pextrw_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRW, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pextrw_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRW, operand_count = 3, ops = {op_gpr64(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_pextrw_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRW, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} }, 905) } +inst_pextrw_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRW, operand_count = 3, ops = {op_gpr64(dst), op_xmm(src), op_imm8(imm), {}} }, 906) } emit_pextrw_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { append(instructions, inst_pextrw_r32_xmm_imm8(dst, src, imm)) } emit_pextrw_r64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM, imm: i8) { append(instructions, inst_pextrw_r64_xmm_imm8(dst, src, imm)) } -inst_pinsrw_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRW, operand_count = 3, ops = {op_xmm(dst), op_gpr32(src), op_imm8(imm), {}} } } -inst_pinsrw_xmm_m16_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 2), op_imm8(imm), {}} } } +inst_pinsrw_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRW, operand_count = 3, ops = {op_xmm(dst), op_gpr32(src), op_imm8(imm), {}} }, 907) } +inst_pinsrw_xmm_m16_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 2), op_imm8(imm), {}} }, 908) } emit_pinsrw_xmm_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32, imm: i8) { append(instructions, inst_pinsrw_xmm_r32_imm8(dst, src, imm)) } emit_pinsrw_xmm_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem16, imm: i8) { append(instructions, inst_pinsrw_xmm_m16_imm8(dst, src, imm)) } inst_pmovmskb_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMOVMSKB, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 909) } @@ -2931,16 +2931,16 @@ inst_pabsd_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_pabsd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PABSD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 948) } emit_pabsd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pabsd_xmm_xmm(dst, src)) } emit_pabsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pabsd_xmm_m128(dst, src)) } -inst_palignr_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PALIGNR, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_palignr_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PALIGNR, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_palignr_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PALIGNR, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 949) } +inst_palignr_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PALIGNR, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 949) } emit_palignr_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_palignr_xmm_xmm_imm8(dst, src, imm)) } emit_palignr_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_palignr_xmm_m128_imm8(dst, src, imm)) } -inst_blendps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .BLENDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_blendps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .BLENDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_blendps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 950) } +inst_blendps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 950) } emit_blendps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_blendps_xmm_xmm_imm8(dst, src, imm)) } emit_blendps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_blendps_xmm_m128_imm8(dst, src, imm)) } -inst_blendpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .BLENDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_blendpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .BLENDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_blendpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 951) } +inst_blendpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 951) } emit_blendpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_blendpd_xmm_xmm_imm8(dst, src, imm)) } emit_blendpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_blendpd_xmm_m128_imm8(dst, src, imm)) } inst_blendvps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDVPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 952) } @@ -2951,64 +2951,64 @@ inst_blendvpd_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_blendvpd_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .BLENDVPD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 953) } emit_blendvpd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_blendvpd_xmm_xmm(dst, src)) } emit_blendvpd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_blendvpd_xmm_m128(dst, src)) } -inst_pblendw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PBLENDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pblendw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PBLENDW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pblendw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PBLENDW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 954) } +inst_pblendw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PBLENDW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 954) } emit_pblendw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pblendw_xmm_xmm_imm8(dst, src, imm)) } emit_pblendw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pblendw_xmm_m128_imm8(dst, src, imm)) } inst_pblendvb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PBLENDVB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 955) } inst_pblendvb_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PBLENDVB, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 955) } emit_pblendvb_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pblendvb_xmm_xmm(dst, src)) } emit_pblendvb_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pblendvb_xmm_m128(dst, src)) } -inst_dpps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .DPPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_dpps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .DPPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_dpps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .DPPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 956) } +inst_dpps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .DPPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 956) } emit_dpps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_dpps_xmm_xmm_imm8(dst, src, imm)) } emit_dpps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_dpps_xmm_m128_imm8(dst, src, imm)) } -inst_dppd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .DPPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_dppd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .DPPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_dppd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .DPPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 957) } +inst_dppd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .DPPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 957) } emit_dppd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_dppd_xmm_xmm_imm8(dst, src, imm)) } emit_dppd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_dppd_xmm_m128_imm8(dst, src, imm)) } -inst_extractps_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .EXTRACTPS, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_extractps_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .EXTRACTPS, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} } } +inst_extractps_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .EXTRACTPS, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} }, 958) } +inst_extractps_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .EXTRACTPS, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} }, 958) } emit_extractps_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { append(instructions, inst_extractps_r32_xmm_imm8(dst, src, imm)) } emit_extractps_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { append(instructions, inst_extractps_m32_xmm_imm8(dst, src, imm)) } -inst_insertps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .INSERTPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_insertps_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .INSERTPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} } } +inst_insertps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .INSERTPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 959) } +inst_insertps_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .INSERTPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} }, 959) } emit_insertps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_insertps_xmm_xmm_imm8(dst, src, imm)) } emit_insertps_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { append(instructions, inst_insertps_xmm_m32_imm8(dst, src, imm)) } -inst_mpsadbw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .MPSADBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_mpsadbw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .MPSADBW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_mpsadbw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .MPSADBW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 960) } +inst_mpsadbw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .MPSADBW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 960) } emit_mpsadbw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_mpsadbw_xmm_xmm_imm8(dst, src, imm)) } emit_mpsadbw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_mpsadbw_xmm_m128_imm8(dst, src, imm)) } inst_packusdw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKUSDW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 961) } inst_packusdw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PACKUSDW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 961) } emit_packusdw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_packusdw_xmm_xmm(dst, src)) } emit_packusdw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_packusdw_xmm_m128(dst, src)) } -inst_pextrb_r8_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR8, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRB, operand_count = 3, ops = {op_gpr8(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pextrb_m8_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem8, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRB, operand_count = 3, ops = {op_mem(dst.mem, 1), op_xmm(src), op_imm8(imm), {}} } } +inst_pextrb_r8_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR8, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRB, operand_count = 3, ops = {op_gpr8(dst), op_xmm(src), op_imm8(imm), {}} }, 962) } +inst_pextrb_m8_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem8, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRB, operand_count = 3, ops = {op_mem(dst.mem, 1), op_xmm(src), op_imm8(imm), {}} }, 962) } emit_pextrb_r8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: XMM, imm: i8) { append(instructions, inst_pextrb_r8_xmm_imm8(dst, src, imm)) } emit_pextrb_m8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: XMM, imm: i8) { append(instructions, inst_pextrb_m8_xmm_imm8(dst, src, imm)) } -inst_pextrd_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRD, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pextrd_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} } } +inst_pextrd_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRD, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} }, 963) } +inst_pextrd_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} }, 963) } emit_pextrd_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { append(instructions, inst_pextrd_r32_xmm_imm8(dst, src, imm)) } emit_pextrd_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { append(instructions, inst_pextrd_m32_xmm_imm8(dst, src, imm)) } -inst_pextrq_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRQ, operand_count = 3, ops = {op_gpr64(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pextrq_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PEXTRQ, operand_count = 3, ops = {op_mem(dst.mem, 8), op_xmm(src), op_imm8(imm), {}} } } +inst_pextrq_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRQ, operand_count = 3, ops = {op_gpr64(dst), op_xmm(src), op_imm8(imm), {}} }, 964) } +inst_pextrq_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PEXTRQ, operand_count = 3, ops = {op_mem(dst.mem, 8), op_xmm(src), op_imm8(imm), {}} }, 964) } emit_pextrq_r64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM, imm: i8) { append(instructions, inst_pextrq_r64_xmm_imm8(dst, src, imm)) } emit_pextrq_m64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM, imm: i8) { append(instructions, inst_pextrq_m64_xmm_imm8(dst, src, imm)) } inst_phminposuw_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PHMINPOSUW, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 965) } inst_phminposuw_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PHMINPOSUW, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 965) } emit_phminposuw_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_phminposuw_xmm_xmm(dst, src)) } emit_phminposuw_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_phminposuw_xmm_m128(dst, src)) } -inst_pinsrb_xmm_r8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRB, operand_count = 3, ops = {op_xmm(dst), op_gpr8(src), op_imm8(imm), {}} } } -inst_pinsrb_xmm_m8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRB, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 1), op_imm8(imm), {}} } } +inst_pinsrb_xmm_r8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRB, operand_count = 3, ops = {op_xmm(dst), op_gpr8(src), op_imm8(imm), {}} }, 966) } +inst_pinsrb_xmm_m8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRB, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 1), op_imm8(imm), {}} }, 966) } emit_pinsrb_xmm_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR8, imm: i8) { append(instructions, inst_pinsrb_xmm_r8_imm8(dst, src, imm)) } emit_pinsrb_xmm_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem8, imm: i8) { append(instructions, inst_pinsrb_xmm_m8_imm8(dst, src, imm)) } -inst_pinsrd_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRD, operand_count = 3, ops = {op_xmm(dst), op_gpr32(src), op_imm8(imm), {}} } } -inst_pinsrd_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} } } +inst_pinsrd_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRD, operand_count = 3, ops = {op_xmm(dst), op_gpr32(src), op_imm8(imm), {}} }, 967) } +inst_pinsrd_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} }, 967) } emit_pinsrd_xmm_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR32, imm: i8) { append(instructions, inst_pinsrd_xmm_r32_imm8(dst, src, imm)) } emit_pinsrd_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { append(instructions, inst_pinsrd_xmm_m32_imm8(dst, src, imm)) } -inst_pinsrq_xmm_r64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRQ, operand_count = 3, ops = {op_xmm(dst), op_gpr64(src), op_imm8(imm), {}} } } -inst_pinsrq_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .PINSRQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} } } +inst_pinsrq_xmm_r64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRQ, operand_count = 3, ops = {op_xmm(dst), op_gpr64(src), op_imm8(imm), {}} }, 968) } +inst_pinsrq_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PINSRQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} }, 968) } emit_pinsrq_xmm_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: GPR64, imm: i8) { append(instructions, inst_pinsrq_xmm_r64_imm8(dst, src, imm)) } emit_pinsrq_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64, imm: i8) { append(instructions, inst_pinsrq_xmm_m64_imm8(dst, src, imm)) } inst_pmaxsb_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PMAXSB, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 969) } @@ -3103,20 +3103,20 @@ inst_ptest_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_ptest_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PTEST, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 991) } emit_ptest_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_ptest_xmm_xmm(dst, src)) } emit_ptest_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_ptest_xmm_m128(dst, src)) } -inst_roundps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_roundps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_roundps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 992) } +inst_roundps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 992) } emit_roundps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_roundps_xmm_xmm_imm8(dst, src, imm)) } emit_roundps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_roundps_xmm_m128_imm8(dst, src, imm)) } -inst_roundpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_roundpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_roundpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 993) } +inst_roundpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 993) } emit_roundpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_roundpd_xmm_xmm_imm8(dst, src, imm)) } emit_roundpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_roundpd_xmm_m128_imm8(dst, src, imm)) } -inst_roundss_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_roundss_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDSS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} } } +inst_roundss_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDSS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 994) } +inst_roundss_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDSS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 4), op_imm8(imm), {}} }, 994) } emit_roundss_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_roundss_xmm_xmm_imm8(dst, src, imm)) } emit_roundss_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem32, imm: i8) { append(instructions, inst_roundss_xmm_m32_imm8(dst, src, imm)) } -inst_roundsd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_roundsd_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .ROUNDSD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} } } +inst_roundsd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 995) } +inst_roundsd_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ROUNDSD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 8), op_imm8(imm), {}} }, 995) } emit_roundsd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_roundsd_xmm_xmm_imm8(dst, src, imm)) } emit_roundsd_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64, imm: i8) { append(instructions, inst_roundsd_xmm_m64_imm8(dst, src, imm)) } inst_pcmpeqq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPEQQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 996) } @@ -3143,28 +3143,28 @@ emit_crc32_r64_r8 :: #force_inline proc(instructions: ^[dynami emit_crc32_r64_m8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem8) { append(instructions, inst_crc32_r64_m8(dst, src)) } emit_crc32_r64_r64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: GPR64) { append(instructions, inst_crc32_r64_r64(dst, src)) } emit_crc32_r64_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: Mem64) { append(instructions, inst_crc32_r64_m64(dst, src)) } -inst_pcmpestri_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPESTRI, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pcmpestri_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPESTRI, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pcmpestri_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPESTRI, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1002) } +inst_pcmpestri_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPESTRI, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1002) } emit_pcmpestri_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pcmpestri_xmm_xmm_imm8(dst, src, imm)) } emit_pcmpestri_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pcmpestri_xmm_m128_imm8(dst, src, imm)) } -inst_pcmpestrm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPESTRM, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pcmpestrm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPESTRM, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pcmpestrm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPESTRM, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1003) } +inst_pcmpestrm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPESTRM, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1003) } emit_pcmpestrm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pcmpestrm_xmm_xmm_imm8(dst, src, imm)) } emit_pcmpestrm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pcmpestrm_xmm_m128_imm8(dst, src, imm)) } -inst_pcmpistri_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPISTRI, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pcmpistri_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPISTRI, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pcmpistri_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPISTRI, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1004) } +inst_pcmpistri_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPISTRI, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1004) } emit_pcmpistri_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pcmpistri_xmm_xmm_imm8(dst, src, imm)) } emit_pcmpistri_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pcmpistri_xmm_m128_imm8(dst, src, imm)) } -inst_pcmpistrm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPISTRM, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pcmpistrm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCMPISTRM, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pcmpistrm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPISTRM, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1005) } +inst_pcmpistrm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPISTRM, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1005) } emit_pcmpistrm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pcmpistrm_xmm_xmm_imm8(dst, src, imm)) } emit_pcmpistrm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pcmpistrm_xmm_m128_imm8(dst, src, imm)) } inst_pcmpgtq_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTQ, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1006) } inst_pcmpgtq_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .PCMPGTQ, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1006) } emit_pcmpgtq_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_pcmpgtq_xmm_xmm(dst, src)) } emit_pcmpgtq_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_pcmpgtq_xmm_m128(dst, src)) } -inst_pclmulqdq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCLMULQDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_pclmulqdq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .PCLMULQDQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_pclmulqdq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCLMULQDQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1007) } +inst_pclmulqdq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .PCLMULQDQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1007) } emit_pclmulqdq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_pclmulqdq_xmm_xmm_imm8(dst, src, imm)) } emit_pclmulqdq_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_pclmulqdq_xmm_m128_imm8(dst, src, imm)) } inst_aesdec_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .AESDEC, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1008) } @@ -3187,8 +3187,8 @@ inst_aesimc_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_aesimc_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .AESIMC, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1012) } emit_aesimc_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_aesimc_xmm_xmm(dst, src)) } emit_aesimc_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_aesimc_xmm_m128(dst, src)) } -inst_aeskeygenassist_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .AESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_aeskeygenassist_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .AESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_aeskeygenassist_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .AESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1013) } +inst_aeskeygenassist_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .AESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1013) } emit_aeskeygenassist_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_aeskeygenassist_xmm_xmm_imm8(dst, src, imm)) } emit_aeskeygenassist_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_aeskeygenassist_xmm_m128_imm8(dst, src, imm)) } inst_sha1msg1_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1MSG1, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1014) } @@ -3203,8 +3203,8 @@ inst_sha1nexte_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_sha1nexte_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1NEXTE, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1016) } emit_sha1nexte_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_sha1nexte_xmm_xmm(dst, src)) } emit_sha1nexte_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_sha1nexte_xmm_m128(dst, src)) } -inst_sha1rnds4_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHA1RNDS4, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_sha1rnds4_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .SHA1RNDS4, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_sha1rnds4_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1RNDS4, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1017) } +inst_sha1rnds4_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA1RNDS4, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1017) } emit_sha1rnds4_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_sha1rnds4_xmm_xmm_imm8(dst, src, imm)) } emit_sha1rnds4_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_sha1rnds4_xmm_m128_imm8(dst, src, imm)) } inst_sha256msg1_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .SHA256MSG1, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1018) } @@ -3475,28 +3475,28 @@ emit_vxorpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynami emit_vxorpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vxorpd_xmm_xmm_m128(dst, src, src2)) } emit_vxorpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vxorpd_ymm_ymm_ymm(dst, src, src2)) } emit_vxorpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vxorpd_ymm_ymm_m256(dst, src, src2)) } -inst_vcmpps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vcmpps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vcmpps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vcmpps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vcmpps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1085) } +inst_vcmpps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1085) } +inst_vcmpps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1086) } +inst_vcmpps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1086) } emit_vcmpps_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vcmpps_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vcmpps_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vcmpps_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vcmpps_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vcmpps_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vcmpps_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vcmpps_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vcmppd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vcmppd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vcmppd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vcmppd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vcmppd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1087) } +inst_vcmppd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1087) } +inst_vcmppd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1088) } +inst_vcmppd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1088) } emit_vcmppd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vcmppd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vcmppd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vcmppd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vcmppd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vcmppd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vcmppd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vcmppd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vcmpss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vcmpss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vcmpss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1089) } +inst_vcmpss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1089) } emit_vcmpss_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vcmpss_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vcmpss_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vcmpss_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vcmpsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vcmpsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCMPSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vcmpsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1090) } +inst_vcmpsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCMPSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1090) } emit_vcmpsd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vcmpsd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vcmpsd_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vcmpsd_xmm_xmm_m64_imm8(dst, src, src2, imm)) } inst_vcomiss_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VCOMISS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1091) } @@ -3515,18 +3515,18 @@ inst_vucomisd_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_vucomisd_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VUCOMISD, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 8), {}, {}} }, 1094) } emit_vucomisd_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vucomisd_xmm_xmm(dst, src)) } emit_vucomisd_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem64) { append(instructions, inst_vucomisd_xmm_m64(dst, src)) } -inst_vshufps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vshufps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vshufps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vshufps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vshufps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1095) } +inst_vshufps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1095) } +inst_vshufps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1096) } +inst_vshufps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1096) } emit_vshufps_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vshufps_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vshufps_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vshufps_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vshufps_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vshufps_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vshufps_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vshufps_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vshufpd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vshufpd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vshufpd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vshufpd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vshufpd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1097) } +inst_vshufpd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1097) } +inst_vshufpd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1098) } +inst_vshufpd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VSHUFPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1098) } emit_vshufpd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vshufpd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vshufpd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vshufpd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vshufpd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vshufpd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -3563,18 +3563,18 @@ emit_vunpckhpd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynami emit_vunpckhpd_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vunpckhpd_xmm_xmm_m128(dst, src, src2)) } emit_vunpckhpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vunpckhpd_ymm_ymm_ymm(dst, src, src2)) } emit_vunpckhpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vunpckhpd_ymm_ymm_m256(dst, src, src2)) } -inst_vblendps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vblendps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vblendps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vblendps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vblendps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1107) } +inst_vblendps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1107) } +inst_vblendps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1108) } +inst_vblendps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1108) } emit_vblendps_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vblendps_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vblendps_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vblendps_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vblendps_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vblendps_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vblendps_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vblendps_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vblendpd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vblendpd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vblendpd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vblendpd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vblendpd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1109) } +inst_vblendpd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1109) } +inst_vblendpd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1110) } +inst_vblendpd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VBLENDPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1110) } emit_vblendpd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vblendpd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vblendpd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vblendpd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vblendpd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vblendpd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -3595,48 +3595,48 @@ emit_vblendvpd_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynami emit_vblendvpd_xmm_xmm_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, src3: XMM) { append(instructions, inst_vblendvpd_xmm_xmm_m128_xmm(dst, src, src2, src3)) } emit_vblendvpd_ymm_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, src3: YMM) { append(instructions, inst_vblendvpd_ymm_ymm_ymm_ymm(dst, src, src2, src3)) } emit_vblendvpd_ymm_ymm_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, src3: YMM) { append(instructions, inst_vblendvpd_ymm_ymm_m256_ymm(dst, src, src2, src3)) } -inst_vdpps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vdpps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vdpps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vdpps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vdpps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1115) } +inst_vdpps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1115) } +inst_vdpps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1116) } +inst_vdpps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDPPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1116) } emit_vdpps_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vdpps_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vdpps_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vdpps_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vdpps_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vdpps_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vdpps_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vdpps_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vdppd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vdppd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } +inst_vdppd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1117) } +inst_vdppd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDPPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1117) } emit_vdppd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vdppd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vdppd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vdppd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } -inst_vroundps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vroundps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vroundps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vroundps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } +inst_vroundps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1118) } +inst_vroundps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1118) } +inst_vroundps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1119) } +inst_vroundps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1119) } emit_vroundps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vroundps_xmm_xmm_imm8(dst, src, imm)) } emit_vroundps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vroundps_xmm_m128_imm8(dst, src, imm)) } emit_vroundps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vroundps_ymm_ymm_imm8(dst, src, imm)) } emit_vroundps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vroundps_ymm_m256_imm8(dst, src, imm)) } -inst_vroundpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vroundpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vroundpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vroundpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } +inst_vroundpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1120) } +inst_vroundpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1120) } +inst_vroundpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1121) } +inst_vroundpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1121) } emit_vroundpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vroundpd_xmm_xmm_imm8(dst, src, imm)) } emit_vroundpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vroundpd_xmm_m128_imm8(dst, src, imm)) } emit_vroundpd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vroundpd_ymm_ymm_imm8(dst, src, imm)) } emit_vroundpd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vroundpd_ymm_m256_imm8(dst, src, imm)) } -inst_vroundss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vroundss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vroundss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1122) } +inst_vroundss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1122) } emit_vroundss_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vroundss_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vroundss_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vroundss_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vroundsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vroundsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VROUNDSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vroundsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1123) } +inst_vroundsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VROUNDSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1123) } emit_vroundsd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vroundsd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vroundsd_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vroundsd_xmm_xmm_m64_imm8(dst, src, src2, imm)) } -inst_vextractps_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VEXTRACTPS, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vextractps_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VEXTRACTPS, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} } } +inst_vextractps_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXTRACTPS, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} }, 1124) } +inst_vextractps_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXTRACTPS, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} }, 1124) } emit_vextractps_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { append(instructions, inst_vextractps_r32_xmm_imm8(dst, src, imm)) } emit_vextractps_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { append(instructions, inst_vextractps_m32_xmm_imm8(dst, src, imm)) } -inst_vinsertps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VINSERTPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vinsertps_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VINSERTPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vinsertps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VINSERTPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1125) } +inst_vinsertps_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VINSERTPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1125) } emit_vinsertps_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vinsertps_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vinsertps_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vinsertps_xmm_xmm_m32_imm8(dst, src, src2, imm)) } inst_vmovaps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMOVAPS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1126) } @@ -4043,10 +4043,10 @@ emit_vpxor_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynami emit_vpxor_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpxor_ymm_ymm_m256(dst, src, src2)) } inst_vpsllw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1248) } inst_vpsllw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1248) } -inst_vpsllw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpsllw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1249) } inst_vpsllw_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1250) } inst_vpsllw_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1250) } -inst_vpsllw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpsllw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1251) } emit_vpsllw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsllw_xmm_xmm_xmm(dst, src, src2)) } emit_vpsllw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsllw_xmm_xmm_m128(dst, src, src2)) } emit_vpsllw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpsllw_xmm_xmm_imm8(dst, src, imm)) } @@ -4055,10 +4055,10 @@ emit_vpsllw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynami emit_vpsllw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpsllw_ymm_ymm_imm8(dst, src, imm)) } inst_vpslld_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1252) } inst_vpslld_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1252) } -inst_vpslld_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpslld_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1253) } inst_vpslld_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1254) } inst_vpslld_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1254) } -inst_vpslld_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpslld_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1255) } emit_vpslld_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpslld_xmm_xmm_xmm(dst, src, src2)) } emit_vpslld_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpslld_xmm_xmm_m128(dst, src, src2)) } emit_vpslld_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpslld_xmm_xmm_imm8(dst, src, imm)) } @@ -4067,10 +4067,10 @@ emit_vpslld_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynami emit_vpslld_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpslld_ymm_ymm_imm8(dst, src, imm)) } inst_vpsllq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1256) } inst_vpsllq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1256) } -inst_vpsllq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpsllq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1257) } inst_vpsllq_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1258) } inst_vpsllq_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1258) } -inst_vpsllq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpsllq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSLLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1259) } emit_vpsllq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsllq_xmm_xmm_xmm(dst, src, src2)) } emit_vpsllq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsllq_xmm_xmm_m128(dst, src, src2)) } emit_vpsllq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpsllq_xmm_xmm_imm8(dst, src, imm)) } @@ -4079,10 +4079,10 @@ emit_vpsllq_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynami emit_vpsllq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpsllq_ymm_ymm_imm8(dst, src, imm)) } inst_vpsrlw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1260) } inst_vpsrlw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1260) } -inst_vpsrlw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpsrlw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1261) } inst_vpsrlw_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1262) } inst_vpsrlw_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1262) } -inst_vpsrlw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpsrlw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1263) } emit_vpsrlw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsrlw_xmm_xmm_xmm(dst, src, src2)) } emit_vpsrlw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsrlw_xmm_xmm_m128(dst, src, src2)) } emit_vpsrlw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpsrlw_xmm_xmm_imm8(dst, src, imm)) } @@ -4091,10 +4091,10 @@ emit_vpsrlw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynami emit_vpsrlw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpsrlw_ymm_ymm_imm8(dst, src, imm)) } inst_vpsrld_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1264) } inst_vpsrld_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1264) } -inst_vpsrld_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpsrld_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1265) } inst_vpsrld_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1266) } inst_vpsrld_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1266) } -inst_vpsrld_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpsrld_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1267) } emit_vpsrld_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsrld_xmm_xmm_xmm(dst, src, src2)) } emit_vpsrld_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsrld_xmm_xmm_m128(dst, src, src2)) } emit_vpsrld_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpsrld_xmm_xmm_imm8(dst, src, imm)) } @@ -4103,10 +4103,10 @@ emit_vpsrld_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynami emit_vpsrld_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpsrld_ymm_ymm_imm8(dst, src, imm)) } inst_vpsrlq_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1268) } inst_vpsrlq_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1268) } -inst_vpsrlq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpsrlq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1269) } inst_vpsrlq_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1270) } inst_vpsrlq_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1270) } -inst_vpsrlq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpsrlq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1271) } emit_vpsrlq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsrlq_xmm_xmm_xmm(dst, src, src2)) } emit_vpsrlq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsrlq_xmm_xmm_m128(dst, src, src2)) } emit_vpsrlq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpsrlq_xmm_xmm_imm8(dst, src, imm)) } @@ -4115,10 +4115,10 @@ emit_vpsrlq_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynami emit_vpsrlq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpsrlq_ymm_ymm_imm8(dst, src, imm)) } inst_vpsraw_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1272) } inst_vpsraw_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1272) } -inst_vpsraw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpsraw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1273) } inst_vpsraw_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1274) } inst_vpsraw_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1274) } -inst_vpsraw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpsraw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1275) } emit_vpsraw_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsraw_xmm_xmm_xmm(dst, src, src2)) } emit_vpsraw_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsraw_xmm_xmm_m128(dst, src, src2)) } emit_vpsraw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpsraw_xmm_xmm_imm8(dst, src, imm)) } @@ -4127,10 +4127,10 @@ emit_vpsraw_ymm_ymm_m128 :: #force_inline proc(instructions: ^[dynami emit_vpsraw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpsraw_ymm_ymm_imm8(dst, src, imm)) } inst_vpsrad_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), {}} }, 1276) } inst_vpsrad_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1276) } -inst_vpsrad_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } +inst_vpsrad_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1277) } inst_vpsrad_ymm_ymm_xmm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), {}} }, 1278) } inst_vpsrad_ymm_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), {}} }, 1278) } -inst_vpsrad_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } +inst_vpsrad_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSRAD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1279) } emit_vpsrad_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vpsrad_xmm_xmm_xmm(dst, src, src2)) } emit_vpsrad_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpsrad_xmm_xmm_m128(dst, src, src2)) } emit_vpsrad_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpsrad_xmm_xmm_imm8(dst, src, imm)) } @@ -4297,62 +4297,62 @@ emit_vpunpckhqdq_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynami emit_vpunpckhqdq_xmm_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128) { append(instructions, inst_vpunpckhqdq_xmm_xmm_m128(dst, src, src2)) } emit_vpunpckhqdq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpunpckhqdq_ymm_ymm_ymm(dst, src, src2)) } emit_vpunpckhqdq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpunpckhqdq_ymm_ymm_m256(dst, src, src2)) } -inst_vpshufd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpshufd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vpshufd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vpshufd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } +inst_vpshufd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1320) } +inst_vpshufd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1320) } +inst_vpshufd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1321) } +inst_vpshufd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1321) } emit_vpshufd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpshufd_xmm_xmm_imm8(dst, src, imm)) } emit_vpshufd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vpshufd_xmm_m128_imm8(dst, src, imm)) } emit_vpshufd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpshufd_ymm_ymm_imm8(dst, src, imm)) } emit_vpshufd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vpshufd_ymm_m256_imm8(dst, src, imm)) } -inst_vpshufhw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpshufhw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vpshufhw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vpshufhw_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } +inst_vpshufhw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1322) } +inst_vpshufhw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1322) } +inst_vpshufhw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1323) } +inst_vpshufhw_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFHW, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1323) } emit_vpshufhw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpshufhw_xmm_xmm_imm8(dst, src, imm)) } emit_vpshufhw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vpshufhw_xmm_m128_imm8(dst, src, imm)) } emit_vpshufhw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpshufhw_ymm_ymm_imm8(dst, src, imm)) } emit_vpshufhw_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vpshufhw_ymm_m256_imm8(dst, src, imm)) } -inst_vpshuflw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpshuflw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vpshuflw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vpshuflw_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } +inst_vpshuflw_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1324) } +inst_vpshuflw_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1324) } +inst_vpshuflw_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1325) } +inst_vpshuflw_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPSHUFLW, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1325) } emit_vpshuflw_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vpshuflw_xmm_xmm_imm8(dst, src, imm)) } emit_vpshuflw_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vpshuflw_xmm_m128_imm8(dst, src, imm)) } emit_vpshuflw_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpshuflw_ymm_ymm_imm8(dst, src, imm)) } emit_vpshuflw_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vpshuflw_ymm_m256_imm8(dst, src, imm)) } -inst_vpextrb_r8_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR8, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRB, operand_count = 3, ops = {op_gpr8(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpextrb_m8_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem8, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRB, operand_count = 3, ops = {op_mem(dst.mem, 1), op_xmm(src), op_imm8(imm), {}} } } +inst_vpextrb_r8_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR8, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRB, operand_count = 3, ops = {op_gpr8(dst), op_xmm(src), op_imm8(imm), {}} }, 1326) } +inst_vpextrb_m8_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem8, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRB, operand_count = 3, ops = {op_mem(dst.mem, 1), op_xmm(src), op_imm8(imm), {}} }, 1326) } emit_vpextrb_r8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR8, src: XMM, imm: i8) { append(instructions, inst_vpextrb_r8_xmm_imm8(dst, src, imm)) } emit_vpextrb_m8_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem8, src: XMM, imm: i8) { append(instructions, inst_vpextrb_m8_xmm_imm8(dst, src, imm)) } -inst_vpextrw_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRW, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpextrw_r16_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRW, operand_count = 3, ops = {op_gpr16(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpextrw_m16_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRW, operand_count = 3, ops = {op_mem(dst.mem, 2), op_xmm(src), op_imm8(imm), {}} } } +inst_vpextrw_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRW, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} }, 1327) } +inst_vpextrw_r16_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR16, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRW, operand_count = 3, ops = {op_gpr16(dst), op_xmm(src), op_imm8(imm), {}} }, 1328) } +inst_vpextrw_m16_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem16, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRW, operand_count = 3, ops = {op_mem(dst.mem, 2), op_xmm(src), op_imm8(imm), {}} }, 1328) } emit_vpextrw_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { append(instructions, inst_vpextrw_r32_xmm_imm8(dst, src, imm)) } emit_vpextrw_r16_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: XMM, imm: i8) { append(instructions, inst_vpextrw_r16_xmm_imm8(dst, src, imm)) } emit_vpextrw_m16_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem16, src: XMM, imm: i8) { append(instructions, inst_vpextrw_m16_xmm_imm8(dst, src, imm)) } -inst_vpextrd_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRD, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpextrd_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} } } +inst_vpextrd_r32_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRD, operand_count = 3, ops = {op_gpr32(dst), op_xmm(src), op_imm8(imm), {}} }, 1329) } +inst_vpextrd_m32_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem32, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRD, operand_count = 3, ops = {op_mem(dst.mem, 4), op_xmm(src), op_imm8(imm), {}} }, 1329) } emit_vpextrd_r32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: XMM, imm: i8) { append(instructions, inst_vpextrd_r32_xmm_imm8(dst, src, imm)) } emit_vpextrd_m32_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem32, src: XMM, imm: i8) { append(instructions, inst_vpextrd_m32_xmm_imm8(dst, src, imm)) } -inst_vpextrq_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRQ, operand_count = 3, ops = {op_gpr64(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vpextrq_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPEXTRQ, operand_count = 3, ops = {op_mem(dst.mem, 8), op_xmm(src), op_imm8(imm), {}} } } +inst_vpextrq_r64_xmm_imm8 :: #force_inline proc "contextless" (dst: GPR64, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRQ, operand_count = 3, ops = {op_gpr64(dst), op_xmm(src), op_imm8(imm), {}} }, 1330) } +inst_vpextrq_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPEXTRQ, operand_count = 3, ops = {op_mem(dst.mem, 8), op_xmm(src), op_imm8(imm), {}} }, 1330) } emit_vpextrq_r64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR64, src: XMM, imm: i8) { append(instructions, inst_vpextrq_r64_xmm_imm8(dst, src, imm)) } emit_vpextrq_m64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM, imm: i8) { append(instructions, inst_vpextrq_m64_xmm_imm8(dst, src, imm)) } -inst_vpinsrb_xmm_xmm_r8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR8, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRB, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr8(src2), op_imm8(imm)} } } -inst_vpinsrb_xmm_xmm_m8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem8, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRB, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 1), op_imm8(imm)} } } +inst_vpinsrb_xmm_xmm_r8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRB, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr8(src2), op_imm8(imm)} }, 1331) } +inst_vpinsrb_xmm_xmm_m8_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem8, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRB, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 1), op_imm8(imm)} }, 1331) } emit_vpinsrb_xmm_xmm_r8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR8, imm: i8) { append(instructions, inst_vpinsrb_xmm_xmm_r8_imm8(dst, src, src2, imm)) } emit_vpinsrb_xmm_xmm_m8_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem8, imm: i8) { append(instructions, inst_vpinsrb_xmm_xmm_m8_imm8(dst, src, src2, imm)) } -inst_vpinsrw_xmm_xmm_r16_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR16, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr16(src2), op_imm8(imm)} } } -inst_vpinsrw_xmm_xmm_m16_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem16, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 2), op_imm8(imm)} } } +inst_vpinsrw_xmm_xmm_r16_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr16(src2), op_imm8(imm)} }, 1332) } +inst_vpinsrw_xmm_xmm_m16_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem16, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 2), op_imm8(imm)} }, 1332) } emit_vpinsrw_xmm_xmm_r16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR16, imm: i8) { append(instructions, inst_vpinsrw_xmm_xmm_r16_imm8(dst, src, src2, imm)) } emit_vpinsrw_xmm_xmm_m16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem16, imm: i8) { append(instructions, inst_vpinsrw_xmm_xmm_m16_imm8(dst, src, src2, imm)) } -inst_vpinsrd_xmm_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr32(src2), op_imm8(imm)} } } -inst_vpinsrd_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vpinsrd_xmm_xmm_r32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr32(src2), op_imm8(imm)} }, 1333) } +inst_vpinsrd_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1333) } emit_vpinsrd_xmm_xmm_r32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR32, imm: i8) { append(instructions, inst_vpinsrd_xmm_xmm_r32_imm8(dst, src, src2, imm)) } emit_vpinsrd_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vpinsrd_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vpinsrq_xmm_xmm_r64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr64(src2), op_imm8(imm)} } } -inst_vpinsrq_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPINSRQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vpinsrq_xmm_xmm_r64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: GPR64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_gpr64(src2), op_imm8(imm)} }, 1334) } +inst_vpinsrq_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPINSRQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1334) } emit_vpinsrq_xmm_xmm_r64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: GPR64, imm: i8) { append(instructions, inst_vpinsrq_xmm_xmm_r64_imm8(dst, src, src2, imm)) } emit_vpinsrq_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vpinsrq_xmm_xmm_m64_imm8(dst, src, src2, imm)) } inst_vpmovmskb_r32_xmm :: #force_inline proc "contextless" (dst: GPR32, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPMOVMSKB, operand_count = 2, ops = {op_gpr32(dst), op_xmm(src), {}, {}} }, 1335) } @@ -4487,18 +4487,18 @@ emit_vpabsd_xmm_xmm :: #force_inline proc(instructions: ^[dynami emit_vpabsd_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vpabsd_xmm_m128(dst, src)) } emit_vpabsd_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM) { append(instructions, inst_vpabsd_ymm_ymm(dst, src)) } emit_vpabsd_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256) { append(instructions, inst_vpabsd_ymm_m256(dst, src)) } -inst_vpalignr_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpalignr_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpalignr_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpalignr_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vpalignr_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1369) } +inst_vpalignr_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1369) } +inst_vpalignr_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1370) } +inst_vpalignr_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPALIGNR, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1370) } emit_vpalignr_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpalignr_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpalignr_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpalignr_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpalignr_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpalignr_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpalignr_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpalignr_ymm_ymm_m256_imm8(dst, src, src2, imm)) } -inst_vpblendw_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpblendw_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpblendw_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpblendw_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vpblendw_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1371) } +inst_vpblendw_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1371) } +inst_vpblendw_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1372) } +inst_vpblendw_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1372) } emit_vpblendw_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpblendw_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpblendw_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpblendw_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpblendw_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpblendw_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -4511,10 +4511,10 @@ emit_vpblendvb_xmm_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynami emit_vpblendvb_xmm_xmm_m128_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, src3: XMM) { append(instructions, inst_vpblendvb_xmm_xmm_m128_xmm(dst, src, src2, src3)) } emit_vpblendvb_ymm_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, src3: YMM) { append(instructions, inst_vpblendvb_ymm_ymm_ymm_ymm(dst, src, src2, src3)) } emit_vpblendvb_ymm_ymm_m256_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, src3: YMM) { append(instructions, inst_vpblendvb_ymm_ymm_m256_ymm(dst, src, src2, src3)) } -inst_vmpsadbw_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vmpsadbw_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vmpsadbw_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vmpsadbw_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vmpsadbw_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1375) } +inst_vmpsadbw_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1375) } +inst_vmpsadbw_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1376) } +inst_vmpsadbw_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VMPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1376) } emit_vmpsadbw_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vmpsadbw_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vmpsadbw_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vmpsadbw_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vmpsadbw_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vmpsadbw_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -4697,10 +4697,10 @@ emit_vpmulld_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynami emit_vpmulld_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpmulld_ymm_ymm_m256(dst, src, src2)) } inst_vmaskmovdqu_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVDQU, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1422) } emit_vmaskmovdqu_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vmaskmovdqu_xmm_xmm(dst, src)) } -inst_vpclmulqdq_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpclmulqdq_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpclmulqdq_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpclmulqdq_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vpclmulqdq_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1423) } +inst_vpclmulqdq_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1423) } +inst_vpclmulqdq_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1424) } +inst_vpclmulqdq_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCLMULQDQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1424) } emit_vpclmulqdq_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpclmulqdq_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpclmulqdq_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpclmulqdq_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpclmulqdq_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpclmulqdq_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -4725,8 +4725,8 @@ inst_vaesimc_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_vaesimc_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESIMC, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 16), {}, {}} }, 1429) } emit_vaesimc_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM) { append(instructions, inst_vaesimc_xmm_xmm(dst, src)) } emit_vaesimc_xmm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128) { append(instructions, inst_vaesimc_xmm_m128(dst, src)) } -inst_vaeskeygenassist_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VAESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vaeskeygenassist_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VAESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } +inst_vaeskeygenassist_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1430) } +inst_vaeskeygenassist_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VAESKEYGENASSIST, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1430) } emit_vaeskeygenassist_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vaeskeygenassist_xmm_xmm_imm8(dst, src, imm)) } emit_vaeskeygenassist_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vaeskeygenassist_xmm_m128_imm8(dst, src, imm)) } inst_vbroadcastss_xmm_m32 :: #force_inline proc "contextless" (dst: XMM, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTSS, operand_count = 2, ops = {op_xmm(dst), op_mem(src.mem, 4), {}, {}} }, 1431) } @@ -4743,16 +4743,16 @@ emit_vbroadcastsd_ymm_m64 :: #force_inline proc(instructions: ^[dynami emit_vbroadcastsd_ymm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: XMM) { append(instructions, inst_vbroadcastsd_ymm_xmm(dst, src)) } inst_vbroadcastf128_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTF128, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1437) } emit_vbroadcastf128_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vbroadcastf128_ymm_m128(dst, src)) } -inst_vextractf128_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VEXTRACTF128, operand_count = 3, ops = {op_xmm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vextractf128_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VEXTRACTF128, operand_count = 3, ops = {op_mem(dst.mem, 16), op_ymm(src), op_imm8(imm), {}} } } +inst_vextractf128_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXTRACTF128, operand_count = 3, ops = {op_xmm(dst), op_ymm(src), op_imm8(imm), {}} }, 1438) } +inst_vextractf128_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXTRACTF128, operand_count = 3, ops = {op_mem(dst.mem, 16), op_ymm(src), op_imm8(imm), {}} }, 1438) } emit_vextractf128_xmm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM, imm: i8) { append(instructions, inst_vextractf128_xmm_ymm_imm8(dst, src, imm)) } emit_vextractf128_m128_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM, imm: i8) { append(instructions, inst_vextractf128_m128_ymm_imm8(dst, src, imm)) } -inst_vinsertf128_ymm_ymm_xmm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VINSERTF128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vinsertf128_ymm_ymm_m128_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VINSERTF128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } +inst_vinsertf128_ymm_ymm_xmm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VINSERTF128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), op_imm8(imm)} }, 1439) } +inst_vinsertf128_ymm_ymm_m128_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VINSERTF128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1439) } emit_vinsertf128_ymm_ymm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM, imm: i8) { append(instructions, inst_vinsertf128_ymm_ymm_xmm_imm8(dst, src, src2, imm)) } emit_vinsertf128_ymm_ymm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128, imm: i8) { append(instructions, inst_vinsertf128_ymm_ymm_m128_imm8(dst, src, src2, imm)) } -inst_vperm2f128_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERM2F128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vperm2f128_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERM2F128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vperm2f128_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERM2F128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1440) } +inst_vperm2f128_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERM2F128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1440) } emit_vperm2f128_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vperm2f128_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vperm2f128_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vperm2f128_ymm_ymm_m256_imm8(dst, src, src2, imm)) } inst_vmaskmovps_xmm_xmm_m128 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VMASKMOVPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), {}} }, 1441) } @@ -4793,16 +4793,16 @@ inst_vzeroupper_none :: #force_inline proc "contextless" () -> In emit_vzeroupper_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_vzeroupper_none()) } inst_vbroadcasti128_ymm_m128 :: #force_inline proc "contextless" (dst: YMM, src: Mem128) -> Instruction { return with_hint(Instruction{ mnemonic = .VBROADCASTI128, operand_count = 2, ops = {op_ymm(dst), op_mem(src.mem, 16), {}, {}} }, 1455) } emit_vbroadcasti128_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vbroadcasti128_ymm_m128(dst, src)) } -inst_vextracti128_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VEXTRACTI128, operand_count = 3, ops = {op_xmm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vextracti128_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VEXTRACTI128, operand_count = 3, ops = {op_mem(dst.mem, 16), op_ymm(src), op_imm8(imm), {}} } } +inst_vextracti128_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXTRACTI128, operand_count = 3, ops = {op_xmm(dst), op_ymm(src), op_imm8(imm), {}} }, 1456) } +inst_vextracti128_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VEXTRACTI128, operand_count = 3, ops = {op_mem(dst.mem, 16), op_ymm(src), op_imm8(imm), {}} }, 1456) } emit_vextracti128_xmm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM, imm: i8) { append(instructions, inst_vextracti128_xmm_ymm_imm8(dst, src, imm)) } emit_vextracti128_m128_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM, imm: i8) { append(instructions, inst_vextracti128_m128_ymm_imm8(dst, src, imm)) } -inst_vinserti128_ymm_ymm_xmm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VINSERTI128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vinserti128_ymm_ymm_m128_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VINSERTI128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } +inst_vinserti128_ymm_ymm_xmm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VINSERTI128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_xmm(src2), op_imm8(imm)} }, 1457) } +inst_vinserti128_ymm_ymm_m128_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VINSERTI128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1457) } emit_vinserti128_ymm_ymm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: XMM, imm: i8) { append(instructions, inst_vinserti128_ymm_ymm_xmm_imm8(dst, src, src2, imm)) } emit_vinserti128_ymm_ymm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem128, imm: i8) { append(instructions, inst_vinserti128_ymm_ymm_m128_imm8(dst, src, src2, imm)) } -inst_vperm2i128_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERM2I128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vperm2i128_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERM2I128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vperm2i128_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERM2I128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1458) } +inst_vperm2i128_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERM2I128, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1458) } emit_vperm2i128_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vperm2i128_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vperm2i128_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vperm2i128_ymm_ymm_m256_imm8(dst, src, src2, imm)) } inst_vpermd_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), {}} }, 1459) } @@ -4813,18 +4813,18 @@ inst_vpermps_ymm_ymm_ymm :: #force_inline proc "contextless" (dst: YM inst_vpermps_ymm_ymm_m256 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), {}} }, 1460) } emit_vpermps_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM) { append(instructions, inst_vpermps_ymm_ymm_ymm(dst, src, src2)) } emit_vpermps_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpermps_ymm_ymm_m256(dst, src, src2)) } -inst_vpermq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERMQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vpermq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERMQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } +inst_vpermq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1461) } +inst_vpermq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1461) } emit_vpermq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpermq_ymm_ymm_imm8(dst, src, imm)) } emit_vpermq_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vpermq_ymm_m256_imm8(dst, src, imm)) } -inst_vpermpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERMPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vpermpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPERMPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } +inst_vpermpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1462) } +inst_vpermpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPERMPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1462) } emit_vpermpd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vpermpd_ymm_ymm_imm8(dst, src, imm)) } emit_vpermpd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vpermpd_ymm_m256_imm8(dst, src, imm)) } -inst_vpblendd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpblendd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpblendd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpblendd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } +inst_vpblendd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1463) } +inst_vpblendd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1463) } +inst_vpblendd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1464) } +inst_vpblendd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPBLENDD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1464) } emit_vpblendd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpblendd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpblendd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpblendd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpblendd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpblendd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -5309,12 +5309,12 @@ emit_vcvtph2ps_ymm_xmm :: #force_inline proc(instructions: ^[dynami emit_vcvtph2ps_ymm_m128 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem128) { append(instructions, inst_vcvtph2ps_ymm_m128(dst, src)) } emit_vcvtph2ps_zmm_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: YMM) { append(instructions, inst_vcvtph2ps_zmm_ymm(dst, src)) } emit_vcvtph2ps_zmm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem256) { append(instructions, inst_vcvtph2ps_zmm_m256(dst, src)) } -inst_vcvtps2ph_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vcvtps2ph_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_mem(dst.mem, 8), op_xmm(src), op_imm8(imm), {}} } } -inst_vcvtps2ph_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_xmm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vcvtps2ph_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_mem(dst.mem, 16), op_ymm(src), op_imm8(imm), {}} } } -inst_vcvtps2ph_ymm_zmm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_ymm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vcvtps2ph_m256_zmm_imm8 :: #force_inline proc "contextless" (dst: Mem256, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_mem(dst.mem, 32), op_zmm(src), op_imm8(imm), {}} } } +inst_vcvtps2ph_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1598) } +inst_vcvtps2ph_m64_xmm_imm8 :: #force_inline proc "contextless" (dst: Mem64, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_mem(dst.mem, 8), op_xmm(src), op_imm8(imm), {}} }, 1598) } +inst_vcvtps2ph_xmm_ymm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_xmm(dst), op_ymm(src), op_imm8(imm), {}} }, 1599) } +inst_vcvtps2ph_m128_ymm_imm8 :: #force_inline proc "contextless" (dst: Mem128, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_mem(dst.mem, 16), op_ymm(src), op_imm8(imm), {}} }, 1599) } +inst_vcvtps2ph_ymm_zmm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_ymm(dst), op_zmm(src), op_imm8(imm), {}} }, 1600) } +inst_vcvtps2ph_m256_zmm_imm8 :: #force_inline proc "contextless" (dst: Mem256, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VCVTPS2PH, operand_count = 3, ops = {op_mem(dst.mem, 32), op_zmm(src), op_imm8(imm), {}} }, 1600) } emit_vcvtps2ph_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vcvtps2ph_xmm_xmm_imm8(dst, src, imm)) } emit_vcvtps2ph_m64_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem64, src: XMM, imm: i8) { append(instructions, inst_vcvtps2ph_m64_xmm_imm8(dst, src, imm)) } emit_vcvtps2ph_xmm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: YMM, imm: i8) { append(instructions, inst_vcvtps2ph_xmm_ymm_imm8(dst, src, imm)) } @@ -5501,96 +5501,96 @@ emit_vblendmpd_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynami emit_vblendmpd_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vblendmpd_ymm_ymm_m256(dst, src, src2)) } emit_vblendmpd_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vblendmpd_zmm_zmm_zmm(dst, src, src2)) } emit_vblendmpd_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vblendmpd_zmm_zmm_m512(dst, src, src2)) } -inst_vpcmpb_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpb_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpb_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpb_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpb_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpb_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpb_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1655) } +inst_vpcmpb_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1655) } +inst_vpcmpb_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1656) } +inst_vpcmpb_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1656) } +inst_vpcmpb_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1657) } +inst_vpcmpb_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1657) } emit_vpcmpb_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpb_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpb_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpb_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpb_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpb_k_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpcmpb_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpb_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpb_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpb_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpb_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpb_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpcmpub_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpub_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpub_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpub_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpub_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpub_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpub_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1658) } +inst_vpcmpub_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1658) } +inst_vpcmpub_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1659) } +inst_vpcmpub_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1659) } +inst_vpcmpub_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1660) } +inst_vpcmpub_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUB, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1660) } emit_vpcmpub_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpub_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpub_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpub_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpub_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpub_k_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpcmpub_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpub_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpub_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpub_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpub_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpub_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpcmpw_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpw_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpw_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpw_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpw_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpw_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpw_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1661) } +inst_vpcmpw_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1661) } +inst_vpcmpw_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1662) } +inst_vpcmpw_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1662) } +inst_vpcmpw_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1663) } +inst_vpcmpw_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1663) } emit_vpcmpw_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpw_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpw_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpw_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpw_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpw_k_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpcmpw_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpw_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpw_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpw_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpw_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpw_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpcmpuw_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpuw_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpuw_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpuw_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpuw_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpuw_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpuw_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1664) } +inst_vpcmpuw_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1664) } +inst_vpcmpuw_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1665) } +inst_vpcmpuw_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1665) } +inst_vpcmpuw_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1666) } +inst_vpcmpuw_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUW, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1666) } emit_vpcmpuw_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpuw_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpuw_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpuw_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpuw_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpuw_k_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpcmpuw_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpuw_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpuw_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpuw_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpuw_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpuw_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpcmpd_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpd_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpd_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpd_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpd_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpd_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpd_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1667) } +inst_vpcmpd_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1667) } +inst_vpcmpd_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1668) } +inst_vpcmpd_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1668) } +inst_vpcmpd_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1669) } +inst_vpcmpd_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1669) } emit_vpcmpd_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpd_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpd_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpd_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpd_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpd_k_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpcmpd_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpd_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpd_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpd_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpd_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpd_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpcmpud_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpud_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpud_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpud_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpud_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpud_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpud_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1670) } +inst_vpcmpud_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1670) } +inst_vpcmpud_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1671) } +inst_vpcmpud_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1671) } +inst_vpcmpud_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1672) } +inst_vpcmpud_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUD, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1672) } emit_vpcmpud_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpud_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpud_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpud_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpud_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpud_k_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpcmpud_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpud_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpud_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpud_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpud_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpud_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpcmpq_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpq_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpq_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpq_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpq_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpq_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpq_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1673) } +inst_vpcmpq_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1673) } +inst_vpcmpq_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1674) } +inst_vpcmpq_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1674) } +inst_vpcmpq_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1675) } +inst_vpcmpq_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1675) } emit_vpcmpq_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpq_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpq_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpq_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpq_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpq_k_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpcmpq_k_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpcmpq_k_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpcmpq_k_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpcmpq_k_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpcmpq_k_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpcmpq_k_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpcmpuq_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpcmpuq_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpcmpuq_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpcmpuq_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpcmpuq_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpcmpuq_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpcmpuq_k_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1676) } +inst_vpcmpuq_k_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1676) } +inst_vpcmpuq_k_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1677) } +inst_vpcmpuq_k_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1677) } +inst_vpcmpuq_k_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1678) } +inst_vpcmpuq_k_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPCMPUQ, operand_count = 4, ops = {op_kreg(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1678) } emit_vpcmpuq_k_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpcmpuq_k_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpcmpuq_k_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpcmpuq_k_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpcmpuq_k_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpcmpuq_k_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -6269,24 +6269,24 @@ emit_vpmovuswb_xmm_ymm :: #force_inline proc(instructions: ^[dynami emit_vpmovuswb_m128_ymm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem128, src: YMM) { append(instructions, inst_vpmovuswb_m128_ymm(dst, src)) } emit_vpmovuswb_ymm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: ZMM) { append(instructions, inst_vpmovuswb_ymm_zmm(dst, src)) } emit_vpmovuswb_m256_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: Mem256, src: ZMM) { append(instructions, inst_vpmovuswb_m256_zmm(dst, src)) } -inst_vprold_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vprold_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vprold_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vprold_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vprold_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vprold_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vprold_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1859) } +inst_vprold_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1859) } +inst_vprold_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1860) } +inst_vprold_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1860) } +inst_vprold_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1861) } +inst_vprold_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1861) } emit_vprold_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vprold_xmm_xmm_imm8(dst, src, imm)) } emit_vprold_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vprold_xmm_m128_imm8(dst, src, imm)) } emit_vprold_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vprold_ymm_ymm_imm8(dst, src, imm)) } emit_vprold_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vprold_ymm_m256_imm8(dst, src, imm)) } emit_vprold_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vprold_zmm_zmm_imm8(dst, src, imm)) } emit_vprold_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vprold_zmm_m512_imm8(dst, src, imm)) } -inst_vprolq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vprolq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vprolq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vprolq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vprolq_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vprolq_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vprolq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1862) } +inst_vprolq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1862) } +inst_vprolq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1863) } +inst_vprolq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1863) } +inst_vprolq_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1864) } +inst_vprolq_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPROLQ, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1864) } emit_vprolq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vprolq_xmm_xmm_imm8(dst, src, imm)) } emit_vprolq_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vprolq_xmm_m128_imm8(dst, src, imm)) } emit_vprolq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vprolq_ymm_ymm_imm8(dst, src, imm)) } @@ -6317,24 +6317,24 @@ emit_vprolvq_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynami emit_vprolvq_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vprolvq_ymm_ymm_m256(dst, src, src2)) } emit_vprolvq_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vprolvq_zmm_zmm_zmm(dst, src, src2)) } emit_vprolvq_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vprolvq_zmm_zmm_m512(dst, src, src2)) } -inst_vprord_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vprord_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vprord_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vprord_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vprord_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vprord_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vprord_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1871) } +inst_vprord_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1871) } +inst_vprord_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1872) } +inst_vprord_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1872) } +inst_vprord_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1873) } +inst_vprord_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1873) } emit_vprord_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vprord_xmm_xmm_imm8(dst, src, imm)) } emit_vprord_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vprord_xmm_m128_imm8(dst, src, imm)) } emit_vprord_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vprord_ymm_ymm_imm8(dst, src, imm)) } emit_vprord_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vprord_ymm_m256_imm8(dst, src, imm)) } emit_vprord_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vprord_zmm_zmm_imm8(dst, src, imm)) } emit_vprord_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vprord_zmm_m512_imm8(dst, src, imm)) } -inst_vprorq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vprorq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vprorq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vprorq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vprorq_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vprorq_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vprorq_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1874) } +inst_vprorq_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1874) } +inst_vprorq_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1875) } +inst_vprorq_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1875) } +inst_vprorq_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1876) } +inst_vprorq_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPRORQ, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1876) } emit_vprorq_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vprorq_xmm_xmm_imm8(dst, src, imm)) } emit_vprorq_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vprorq_xmm_m128_imm8(dst, src, imm)) } emit_vprorq_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vprorq_ymm_ymm_imm8(dst, src, imm)) } @@ -6457,100 +6457,100 @@ emit_vpsrlvw_ymm_ymm_ymm :: #force_inline proc(instructions: ^[dynami emit_vpsrlvw_ymm_ymm_m256 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256) { append(instructions, inst_vpsrlvw_ymm_ymm_m256(dst, src, src2)) } emit_vpsrlvw_zmm_zmm_zmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM) { append(instructions, inst_vpsrlvw_zmm_zmm_zmm(dst, src, src2)) } emit_vpsrlvw_zmm_zmm_m512 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512) { append(instructions, inst_vpsrlvw_zmm_zmm_m512(dst, src, src2)) } -inst_vrangeps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vrangeps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vrangeps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vrangeps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vrangeps_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vrangeps_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vrangeps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1919) } +inst_vrangeps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1919) } +inst_vrangeps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1920) } +inst_vrangeps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1920) } +inst_vrangeps_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1921) } +inst_vrangeps_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1921) } emit_vrangeps_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vrangeps_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vrangeps_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vrangeps_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vrangeps_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vrangeps_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vrangeps_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vrangeps_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_vrangeps_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vrangeps_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vrangeps_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vrangeps_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vrangepd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vrangepd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vrangepd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vrangepd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vrangepd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vrangepd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vrangepd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1922) } +inst_vrangepd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1922) } +inst_vrangepd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1923) } +inst_vrangepd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1923) } +inst_vrangepd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1924) } +inst_vrangepd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGEPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1924) } emit_vrangepd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vrangepd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vrangepd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vrangepd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vrangepd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vrangepd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vrangepd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vrangepd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_vrangepd_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vrangepd_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vrangepd_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vrangepd_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vrangess_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vrangess_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vrangess_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1925) } +inst_vrangess_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1925) } emit_vrangess_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vrangess_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vrangess_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vrangess_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vrangesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vrangesd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRANGESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vrangesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1926) } +inst_vrangesd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRANGESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1926) } emit_vrangesd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vrangesd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vrangesd_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vrangesd_xmm_xmm_m64_imm8(dst, src, src2, imm)) } -inst_vreduceps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vreduceps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vreduceps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vreduceps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vreduceps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vreduceps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vreduceps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1927) } +inst_vreduceps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1927) } +inst_vreduceps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1928) } +inst_vreduceps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1928) } +inst_vreduceps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1929) } +inst_vreduceps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPS, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1929) } emit_vreduceps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vreduceps_xmm_xmm_imm8(dst, src, imm)) } emit_vreduceps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vreduceps_xmm_m128_imm8(dst, src, imm)) } emit_vreduceps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vreduceps_ymm_ymm_imm8(dst, src, imm)) } emit_vreduceps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vreduceps_ymm_m256_imm8(dst, src, imm)) } emit_vreduceps_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vreduceps_zmm_zmm_imm8(dst, src, imm)) } emit_vreduceps_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vreduceps_zmm_m512_imm8(dst, src, imm)) } -inst_vreducepd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vreducepd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vreducepd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vreducepd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vreducepd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vreducepd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vreducepd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1930) } +inst_vreducepd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1930) } +inst_vreducepd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1931) } +inst_vreducepd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1931) } +inst_vreducepd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1932) } +inst_vreducepd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCEPD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1932) } emit_vreducepd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vreducepd_xmm_xmm_imm8(dst, src, imm)) } emit_vreducepd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vreducepd_xmm_m128_imm8(dst, src, imm)) } emit_vreducepd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vreducepd_ymm_ymm_imm8(dst, src, imm)) } emit_vreducepd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vreducepd_ymm_m256_imm8(dst, src, imm)) } emit_vreducepd_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vreducepd_zmm_zmm_imm8(dst, src, imm)) } emit_vreducepd_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vreducepd_zmm_m512_imm8(dst, src, imm)) } -inst_vreducess_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vreducess_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vreducess_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1933) } +inst_vreducess_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1933) } emit_vreducess_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vreducess_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vreducess_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vreducess_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vreducesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vreducesd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VREDUCESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vreducesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1934) } +inst_vreducesd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VREDUCESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1934) } emit_vreducesd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vreducesd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vreducesd_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vreducesd_xmm_xmm_m64_imm8(dst, src, src2, imm)) } -inst_vrndscaleps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vrndscaleps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vrndscaleps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vrndscaleps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vrndscaleps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vrndscaleps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vrndscaleps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1935) } +inst_vrndscaleps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1935) } +inst_vrndscaleps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1936) } +inst_vrndscaleps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1936) } +inst_vrndscaleps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1937) } +inst_vrndscaleps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPS, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1937) } emit_vrndscaleps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vrndscaleps_xmm_xmm_imm8(dst, src, imm)) } emit_vrndscaleps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vrndscaleps_xmm_m128_imm8(dst, src, imm)) } emit_vrndscaleps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vrndscaleps_ymm_ymm_imm8(dst, src, imm)) } emit_vrndscaleps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vrndscaleps_ymm_m256_imm8(dst, src, imm)) } emit_vrndscaleps_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vrndscaleps_zmm_zmm_imm8(dst, src, imm)) } emit_vrndscaleps_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vrndscaleps_zmm_m512_imm8(dst, src, imm)) } -inst_vrndscalepd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vrndscalepd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vrndscalepd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vrndscalepd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vrndscalepd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vrndscalepd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vrndscalepd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1938) } +inst_vrndscalepd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1938) } +inst_vrndscalepd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1939) } +inst_vrndscalepd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1939) } +inst_vrndscalepd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1940) } +inst_vrndscalepd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALEPD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1940) } emit_vrndscalepd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vrndscalepd_xmm_xmm_imm8(dst, src, imm)) } emit_vrndscalepd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vrndscalepd_xmm_m128_imm8(dst, src, imm)) } emit_vrndscalepd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vrndscalepd_ymm_ymm_imm8(dst, src, imm)) } emit_vrndscalepd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vrndscalepd_ymm_m256_imm8(dst, src, imm)) } emit_vrndscalepd_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vrndscalepd_zmm_zmm_imm8(dst, src, imm)) } emit_vrndscalepd_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vrndscalepd_zmm_m512_imm8(dst, src, imm)) } -inst_vrndscaless_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vrndscaless_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vrndscaless_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1941) } +inst_vrndscaless_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALESS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1941) } emit_vrndscaless_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vrndscaless_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vrndscaless_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vrndscaless_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vrndscalesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vrndscalesd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VRNDSCALESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vrndscalesd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1942) } +inst_vrndscalesd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VRNDSCALESD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1942) } emit_vrndscalesd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vrndscalesd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vrndscalesd_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vrndscalesd_xmm_xmm_m64_imm8(dst, src, src2, imm)) } inst_vrsqrt14ps_xmm_xmm :: #force_inline proc "contextless" (dst: XMM, src: XMM) -> Instruction { return with_hint(Instruction{ mnemonic = .VRSQRT14PS, operand_count = 2, ops = {op_xmm(dst), op_xmm(src), {}, {}} }, 1943) } @@ -6681,156 +6681,156 @@ inst_vgetexpsd_xmm_xmm_xmm :: #force_inline proc "contextless" (dst: XM inst_vgetexpsd_xmm_xmm_m64 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETEXPSD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), {}} }, 1974) } emit_vgetexpsd_xmm_xmm_xmm :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM) { append(instructions, inst_vgetexpsd_xmm_xmm_xmm(dst, src, src2)) } emit_vgetexpsd_xmm_xmm_m64 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64) { append(instructions, inst_vgetexpsd_xmm_xmm_m64(dst, src, src2)) } -inst_vgetmantps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vgetmantps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vgetmantps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vgetmantps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vgetmantps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vgetmantps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vgetmantps_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1975) } +inst_vgetmantps_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1975) } +inst_vgetmantps_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1976) } +inst_vgetmantps_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1976) } +inst_vgetmantps_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1977) } +inst_vgetmantps_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPS, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1977) } emit_vgetmantps_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vgetmantps_xmm_xmm_imm8(dst, src, imm)) } emit_vgetmantps_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vgetmantps_xmm_m128_imm8(dst, src, imm)) } emit_vgetmantps_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vgetmantps_ymm_ymm_imm8(dst, src, imm)) } emit_vgetmantps_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vgetmantps_ymm_m256_imm8(dst, src, imm)) } emit_vgetmantps_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vgetmantps_zmm_zmm_imm8(dst, src, imm)) } emit_vgetmantps_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vgetmantps_zmm_m512_imm8(dst, src, imm)) } -inst_vgetmantpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vgetmantpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vgetmantpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vgetmantpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vgetmantpd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vgetmantpd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vgetmantpd_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_xmm(dst), op_xmm(src), op_imm8(imm), {}} }, 1978) } +inst_vgetmantpd_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_xmm(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1978) } +inst_vgetmantpd_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_ymm(dst), op_ymm(src), op_imm8(imm), {}} }, 1979) } +inst_vgetmantpd_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_ymm(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1979) } +inst_vgetmantpd_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_zmm(dst), op_zmm(src), op_imm8(imm), {}} }, 1980) } +inst_vgetmantpd_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTPD, operand_count = 3, ops = {op_zmm(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1980) } emit_vgetmantpd_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, imm: i8) { append(instructions, inst_vgetmantpd_xmm_xmm_imm8(dst, src, imm)) } emit_vgetmantpd_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: Mem128, imm: i8) { append(instructions, inst_vgetmantpd_xmm_m128_imm8(dst, src, imm)) } emit_vgetmantpd_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, imm: i8) { append(instructions, inst_vgetmantpd_ymm_ymm_imm8(dst, src, imm)) } emit_vgetmantpd_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: Mem256, imm: i8) { append(instructions, inst_vgetmantpd_ymm_m256_imm8(dst, src, imm)) } emit_vgetmantpd_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, imm: i8) { append(instructions, inst_vgetmantpd_zmm_zmm_imm8(dst, src, imm)) } emit_vgetmantpd_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: Mem512, imm: i8) { append(instructions, inst_vgetmantpd_zmm_m512_imm8(dst, src, imm)) } -inst_vgetmantss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vgetmantss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vgetmantss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1981) } +inst_vgetmantss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1981) } emit_vgetmantss_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vgetmantss_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vgetmantss_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vgetmantss_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vgetmantsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vgetmantsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VGETMANTSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vgetmantsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1982) } +inst_vgetmantsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VGETMANTSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1982) } emit_vgetmantsd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vgetmantsd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vgetmantsd_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vgetmantsd_xmm_xmm_m64_imm8(dst, src, src2, imm)) } -inst_vfixupimmps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vfixupimmps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vfixupimmps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vfixupimmps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vfixupimmps_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vfixupimmps_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vfixupimmps_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1983) } +inst_vfixupimmps_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1983) } +inst_vfixupimmps_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1984) } +inst_vfixupimmps_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1984) } +inst_vfixupimmps_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1985) } +inst_vfixupimmps_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPS, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1985) } emit_vfixupimmps_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vfixupimmps_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vfixupimmps_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vfixupimmps_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vfixupimmps_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vfixupimmps_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vfixupimmps_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vfixupimmps_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_vfixupimmps_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vfixupimmps_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vfixupimmps_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vfixupimmps_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vfixupimmpd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vfixupimmpd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vfixupimmpd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vfixupimmpd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vfixupimmpd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vfixupimmpd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vfixupimmpd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1986) } +inst_vfixupimmpd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1986) } +inst_vfixupimmpd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 1987) } +inst_vfixupimmpd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 1987) } +inst_vfixupimmpd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 1988) } +inst_vfixupimmpd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMPD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 1988) } emit_vfixupimmpd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vfixupimmpd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vfixupimmpd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vfixupimmpd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vfixupimmpd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vfixupimmpd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vfixupimmpd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vfixupimmpd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_vfixupimmpd_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vfixupimmpd_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vfixupimmpd_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vfixupimmpd_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vfixupimmss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vfixupimmss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} } } +inst_vfixupimmss_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1989) } +inst_vfixupimmss_xmm_xmm_m32_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMSS, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 4), op_imm8(imm)} }, 1989) } emit_vfixupimmss_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vfixupimmss_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vfixupimmss_xmm_xmm_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem32, imm: i8) { append(instructions, inst_vfixupimmss_xmm_xmm_m32_imm8(dst, src, src2, imm)) } -inst_vfixupimmsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vfixupimmsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFIXUPIMMSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} } } +inst_vfixupimmsd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1990) } +inst_vfixupimmsd_xmm_xmm_m64_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFIXUPIMMSD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 8), op_imm8(imm)} }, 1990) } emit_vfixupimmsd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vfixupimmsd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vfixupimmsd_xmm_xmm_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem64, imm: i8) { append(instructions, inst_vfixupimmsd_xmm_xmm_m64_imm8(dst, src, src2, imm)) } -inst_vfpclassps_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vfpclassps_k_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vfpclassps_k_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vfpclassps_k_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vfpclassps_k_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vfpclassps_k_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vfpclassps_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} }, 1991) } +inst_vfpclassps_k_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1991) } +inst_vfpclassps_k_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_imm8(imm), {}} }, 1992) } +inst_vfpclassps_k_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1992) } +inst_vfpclassps_k_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_imm8(imm), {}} }, 1993) } +inst_vfpclassps_k_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1993) } emit_vfpclassps_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { append(instructions, inst_vfpclassps_k_xmm_imm8(dst, src, imm)) } emit_vfpclassps_k_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem128, imm: i8) { append(instructions, inst_vfpclassps_k_m128_imm8(dst, src, imm)) } emit_vfpclassps_k_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, imm: i8) { append(instructions, inst_vfpclassps_k_ymm_imm8(dst, src, imm)) } emit_vfpclassps_k_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem256, imm: i8) { append(instructions, inst_vfpclassps_k_m256_imm8(dst, src, imm)) } emit_vfpclassps_k_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, imm: i8) { append(instructions, inst_vfpclassps_k_zmm_imm8(dst, src, imm)) } emit_vfpclassps_k_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem512, imm: i8) { append(instructions, inst_vfpclassps_k_m512_imm8(dst, src, imm)) } -inst_vfpclasspd_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vfpclasspd_k_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 16), op_imm8(imm), {}} } } -inst_vfpclasspd_k_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_imm8(imm), {}} } } -inst_vfpclasspd_k_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 32), op_imm8(imm), {}} } } -inst_vfpclasspd_k_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_imm8(imm), {}} } } -inst_vfpclasspd_k_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 64), op_imm8(imm), {}} } } +inst_vfpclasspd_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} }, 1994) } +inst_vfpclasspd_k_m128_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 16), op_imm8(imm), {}} }, 1994) } +inst_vfpclasspd_k_ymm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_ymm(src), op_imm8(imm), {}} }, 1995) } +inst_vfpclasspd_k_m256_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 32), op_imm8(imm), {}} }, 1995) } +inst_vfpclasspd_k_zmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_zmm(src), op_imm8(imm), {}} }, 1996) } +inst_vfpclasspd_k_m512_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSPD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 64), op_imm8(imm), {}} }, 1996) } emit_vfpclasspd_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { append(instructions, inst_vfpclasspd_k_xmm_imm8(dst, src, imm)) } emit_vfpclasspd_k_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem128, imm: i8) { append(instructions, inst_vfpclasspd_k_m128_imm8(dst, src, imm)) } emit_vfpclasspd_k_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: YMM, imm: i8) { append(instructions, inst_vfpclasspd_k_ymm_imm8(dst, src, imm)) } emit_vfpclasspd_k_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem256, imm: i8) { append(instructions, inst_vfpclasspd_k_m256_imm8(dst, src, imm)) } emit_vfpclasspd_k_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: ZMM, imm: i8) { append(instructions, inst_vfpclasspd_k_zmm_imm8(dst, src, imm)) } emit_vfpclasspd_k_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem512, imm: i8) { append(instructions, inst_vfpclasspd_k_m512_imm8(dst, src, imm)) } -inst_vfpclassss_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSSS, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vfpclassss_k_m32_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem32, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSSS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 4), op_imm8(imm), {}} } } +inst_vfpclassss_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSSS, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} }, 1997) } +inst_vfpclassss_k_m32_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem32, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSSS, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 4), op_imm8(imm), {}} }, 1997) } emit_vfpclassss_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { append(instructions, inst_vfpclassss_k_xmm_imm8(dst, src, imm)) } emit_vfpclassss_k_m32_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem32, imm: i8) { append(instructions, inst_vfpclassss_k_m32_imm8(dst, src, imm)) } -inst_vfpclasssd_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSSD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} } } -inst_vfpclasssd_k_m64_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem64, imm: i8) -> Instruction { return Instruction{ mnemonic = .VFPCLASSSD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 8), op_imm8(imm), {}} } } +inst_vfpclasssd_k_xmm_imm8 :: #force_inline proc "contextless" (dst: KREG, src: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSSD, operand_count = 3, ops = {op_kreg(dst), op_xmm(src), op_imm8(imm), {}} }, 1998) } +inst_vfpclasssd_k_m64_imm8 :: #force_inline proc "contextless" (dst: KREG, src: Mem64, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VFPCLASSSD, operand_count = 3, ops = {op_kreg(dst), op_mem(src.mem, 8), op_imm8(imm), {}} }, 1998) } emit_vfpclasssd_k_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: XMM, imm: i8) { append(instructions, inst_vfpclasssd_k_xmm_imm8(dst, src, imm)) } emit_vfpclasssd_k_m64_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: Mem64, imm: i8) { append(instructions, inst_vfpclasssd_k_m64_imm8(dst, src, imm)) } -inst_valignq_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_valignq_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_valignq_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_valignq_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_valignq_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_valignq_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_valignq_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 1999) } +inst_valignq_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 1999) } +inst_valignq_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 2000) } +inst_valignq_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 2000) } +inst_valignq_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 2001) } +inst_valignq_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGNQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 2001) } emit_valignq_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_valignq_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_valignq_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_valignq_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_valignq_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_valignq_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_valignq_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_valignq_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_valignq_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_valignq_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_valignq_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_valignq_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_valignd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_valignd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_valignd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_valignd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_valignd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_valignd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_valignd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 2002) } +inst_valignd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 2002) } +inst_valignd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 2003) } +inst_valignd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 2003) } +inst_valignd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 2004) } +inst_valignd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VALIGND, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 2004) } emit_valignd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_valignd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_valignd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_valignd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_valignd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_valignd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_valignd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_valignd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_valignd_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_valignd_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_valignd_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_valignd_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vdbpsadbw_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vdbpsadbw_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vdbpsadbw_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vdbpsadbw_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vdbpsadbw_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vdbpsadbw_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vdbpsadbw_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 2005) } +inst_vdbpsadbw_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 2005) } +inst_vdbpsadbw_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 2006) } +inst_vdbpsadbw_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 2006) } +inst_vdbpsadbw_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 2007) } +inst_vdbpsadbw_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VDBPSADBW, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 2007) } emit_vdbpsadbw_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vdbpsadbw_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vdbpsadbw_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vdbpsadbw_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vdbpsadbw_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vdbpsadbw_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vdbpsadbw_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vdbpsadbw_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_vdbpsadbw_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vdbpsadbw_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vdbpsadbw_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vdbpsadbw_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpternlogd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpternlogd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpternlogd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpternlogd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpternlogd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpternlogd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpternlogd_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 2008) } +inst_vpternlogd_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 2008) } +inst_vpternlogd_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 2009) } +inst_vpternlogd_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 2009) } +inst_vpternlogd_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 2010) } +inst_vpternlogd_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGD, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 2010) } emit_vpternlogd_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpternlogd_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpternlogd_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpternlogd_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpternlogd_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpternlogd_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } emit_vpternlogd_ymm_ymm_m256_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: Mem256, imm: i8) { append(instructions, inst_vpternlogd_ymm_ymm_m256_imm8(dst, src, src2, imm)) } emit_vpternlogd_zmm_zmm_zmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: ZMM, imm: i8) { append(instructions, inst_vpternlogd_zmm_zmm_zmm_imm8(dst, src, src2, imm)) } emit_vpternlogd_zmm_zmm_m512_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: ZMM, src: ZMM, src2: Mem512, imm: i8) { append(instructions, inst_vpternlogd_zmm_zmm_m512_imm8(dst, src, src2, imm)) } -inst_vpternlogq_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} } } -inst_vpternlogq_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} } } -inst_vpternlogq_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} } } -inst_vpternlogq_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} } } -inst_vpternlogq_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} } } -inst_vpternlogq_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} } } +inst_vpternlogq_xmm_xmm_xmm_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: XMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_xmm(src2), op_imm8(imm)} }, 2011) } +inst_vpternlogq_xmm_xmm_m128_imm8 :: #force_inline proc "contextless" (dst: XMM, src: XMM, src2: Mem128, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_xmm(dst), op_xmm(src), op_mem(src2.mem, 16), op_imm8(imm)} }, 2011) } +inst_vpternlogq_ymm_ymm_ymm_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: YMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_ymm(src2), op_imm8(imm)} }, 2012) } +inst_vpternlogq_ymm_ymm_m256_imm8 :: #force_inline proc "contextless" (dst: YMM, src: YMM, src2: Mem256, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_ymm(dst), op_ymm(src), op_mem(src2.mem, 32), op_imm8(imm)} }, 2012) } +inst_vpternlogq_zmm_zmm_zmm_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: ZMM, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_zmm(src2), op_imm8(imm)} }, 2013) } +inst_vpternlogq_zmm_zmm_m512_imm8 :: #force_inline proc "contextless" (dst: ZMM, src: ZMM, src2: Mem512, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .VPTERNLOGQ, operand_count = 4, ops = {op_zmm(dst), op_zmm(src), op_mem(src2.mem, 64), op_imm8(imm)} }, 2013) } emit_vpternlogq_xmm_xmm_xmm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: XMM, imm: i8) { append(instructions, inst_vpternlogq_xmm_xmm_xmm_imm8(dst, src, src2, imm)) } emit_vpternlogq_xmm_xmm_m128_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: XMM, src: XMM, src2: Mem128, imm: i8) { append(instructions, inst_vpternlogq_xmm_xmm_m128_imm8(dst, src, src2, imm)) } emit_vpternlogq_ymm_ymm_ymm_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: YMM, src: YMM, src2: YMM, imm: i8) { append(instructions, inst_vpternlogq_ymm_ymm_ymm_imm8(dst, src, src2, imm)) } @@ -6937,21 +6937,21 @@ inst_kortestq_k_k :: #force_inline proc "contextless" (dst: KR emit_kortestq_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kortestq_k_k(dst, src)) } inst_kortestd_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KORTESTD, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2056) } emit_kortestd_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_kortestd_k_k(dst, src)) } -inst_kshiftlw_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTLW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftlw_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTLW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2057) } emit_kshiftlw_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftlw_k_k_imm8(dst, src, imm)) } -inst_kshiftlb_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTLB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftlb_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTLB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2058) } emit_kshiftlb_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftlb_k_k_imm8(dst, src, imm)) } -inst_kshiftlq_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTLQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftlq_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTLQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2059) } emit_kshiftlq_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftlq_k_k_imm8(dst, src, imm)) } -inst_kshiftld_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTLD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftld_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTLD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2060) } emit_kshiftld_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftld_k_k_imm8(dst, src, imm)) } -inst_kshiftrw_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTRW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftrw_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTRW, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2061) } emit_kshiftrw_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftrw_k_k_imm8(dst, src, imm)) } -inst_kshiftrb_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTRB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftrb_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTRB, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2062) } emit_kshiftrb_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftrb_k_k_imm8(dst, src, imm)) } -inst_kshiftrq_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTRQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftrq_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTRQ, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2063) } emit_kshiftrq_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftrq_k_k_imm8(dst, src, imm)) } -inst_kshiftrd_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return Instruction{ mnemonic = .KSHIFTRD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} } } +inst_kshiftrd_k_k_imm8 :: #force_inline proc "contextless" (dst: KREG, src: KREG, imm: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .KSHIFTRD, operand_count = 3, ops = {op_kreg(dst), op_kreg(src), op_imm8(imm), {}} }, 2064) } emit_kshiftrd_k_k_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG, imm: i8) { append(instructions, inst_kshiftrd_k_k_imm8(dst, src, imm)) } inst_ktestw_k_k :: #force_inline proc "contextless" (dst: KREG, src: KREG) -> Instruction { return with_hint(Instruction{ mnemonic = .KTESTW, operand_count = 2, ops = {op_kreg(dst), op_kreg(src), {}, {}} }, 2065) } emit_ktestw_k_k :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: KREG, src: KREG) { append(instructions, inst_ktestw_k_k(dst, src)) } @@ -7529,7 +7529,7 @@ inst_bound_r16_m :: #force_inline proc "contextless" (dst: GP inst_bound_r32_m32 :: #force_inline proc "contextless" (dst: GPR32, src: Mem32) -> Instruction { return with_hint(Instruction{ mnemonic = .BOUND, operand_count = 2, ops = {op_gpr32(dst), op_mem(src.mem, 4), {}, {}} }, 2339) } emit_bound_r16_m :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR16, src: Memory) { append(instructions, inst_bound_r16_m(dst, src)) } emit_bound_r32_m32 :: #force_inline proc(instructions: ^[dynamic]Instruction, dst: GPR32, src: Mem32) { append(instructions, inst_bound_r32_m32(dst, src)) } -inst_enter_imm16_imm8 :: #force_inline proc "contextless" (imm: i16, imm2: i8) -> Instruction { return Instruction{ mnemonic = .ENTER, operand_count = 2, ops = {op_imm16(imm), op_imm8(imm2), {}, {}} } } +inst_enter_imm16_imm8 :: #force_inline proc "contextless" (imm: i16, imm2: i8) -> Instruction { return with_hint(Instruction{ mnemonic = .ENTER, operand_count = 2, ops = {op_imm16(imm), op_imm8(imm2), {}, {}} }, 2340) } emit_enter_imm16_imm8 :: #force_inline proc(instructions: ^[dynamic]Instruction, imm: i16, imm2: i8) { append(instructions, inst_enter_imm16_imm8(imm, imm2)) } inst_leave_none :: #force_inline proc "contextless" () -> Instruction { return with_hint(Instruction{ mnemonic = .LEAVE, operand_count = 0, ops = {{}, {}, {}, {}} }, 2341) } emit_leave_none :: #force_inline proc(instructions: ^[dynamic]Instruction) { append(instructions, inst_leave_none()) } diff --git a/core/rexcode/isa/x86/tests/test.odin b/core/rexcode/isa/x86/tests/test.odin index a0c65339c..75604e36c 100644 --- a/core/rexcode/isa/x86/tests/test.odin +++ b/core/rexcode/isa/x86/tests/test.odin @@ -3229,9 +3229,16 @@ run_typed_builder_tests :: proc() { tb_check("push r64", x86.inst_push_r64(.R11), x86.inst_r(.PUSH, x86.R11)) tb_check("pop r64", x86.inst_pop_r64(.R12), x86.inst_r(.POP, x86.R12)) - // immediate forms (no hint -- value-dependent; must still be correct) - tb_check("mov r32,imm32", x86.inst_mov_r32_imm32(.EAX, 0x12345678), x86.inst_r_i(.MOV, x86.EAX, 0x12345678, 4)) - tb_check("mov r64,imm64", x86.inst_mov_r64_imm64(.RAX, 0x1122334455667788), x86.inst_r_i(.MOV, x86.RAX, 0x1122334455667788, 8)) + // immediate forms -- hinted (the typed builder honors its declared width). + // Each must stay byte-identical to the generic same-width builder. + tb_check("mov r32,imm32", x86.inst_mov_r32_imm32(.EAX, 0x12345678), x86.inst_r_i(.MOV, x86.EAX, 0x12345678, 4)) + tb_check("mov r64,imm64", x86.inst_mov_r64_imm64(.RAX, 0x1122334455667788), x86.inst_r_i(.MOV, x86.RAX, 0x1122334455667788, 8)) + tb_check("mov r32,imm32 sm", x86.inst_mov_r32_imm32(.ECX, 5), x86.inst_r_i(.MOV, x86.ECX, 5, 4)) + tb_check("add r32,imm32", x86.inst_add_r32_imm32(.EAX, 100000), x86.inst_r_i(.ADD, x86.EAX, 100000, 4)) + tb_check("add r64,imm32", x86.inst_add_r64_imm32(.RAX, 42), x86.inst_r_i(.ADD, x86.RAX, 42, 4)) + tb_check("cmp r32,imm32", x86.inst_cmp_r32_imm32(.EDX, 100), x86.inst_r_i(.CMP, x86.EDX, 100, 4)) + tb_check("sub r64,imm32", x86.inst_sub_r64_imm32(.RBX, 256), x86.inst_r_i(.SUB, x86.RBX, 256, 4)) + tb_check("and r32,imm32", x86.inst_and_r32_imm32(.ESI, 0xFF), x86.inst_r_i(.AND, x86.ESI, 0xFF, 4)) } // ============================================================================= diff --git a/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin b/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin index 6e7992d22..ea0820a06 100644 --- a/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin +++ b/core/rexcode/isa/x86/tools/gen_mnemonic_builders.odin @@ -341,15 +341,16 @@ can_generate_builder :: proc(enc: x86.Encoding) -> bool { return !has_any_operand || has_explicit } -// A form is safe to pre-match (bake an enc_hint) only when the matcher's pick is -// VALUE-independent: it has no immediate or relative operand. Those select -// imm8-vs-imm32 / rel8-vs-rel32 by the runtime value, so the matcher may pick a -// shorter form than a typed builder's nominal one -- baking would diverge from -// the matcher (and from llvm-mc). Such forms keep enc_hint=0 (matcher path). +// A form is safe to pre-match (bake an enc_hint) unless the pick depends on a +// *relative* target whose size (rel8 vs rel32) the matcher chooses by value -- +// those keep enc_hint=0 (matcher path). Immediate forms ARE hinted: a typed +// builder names its immediate width (inst_add_r32_imm32 vs _imm8), so honoring +// that width is the builder's contract, and skipping the match scan makes the +// very common immediate instructions as fast as the register ones. form_is_hintable :: proc(enc: x86.Encoding) -> bool { for op in enc.ops { #partial switch op { - case .IMM8, .IMM16, .IMM32, .IMM64, .IMM8SX, .REL8, .REL32: + case .REL8, .REL32: return false } }